Claude Code on the Web

Claude Code on the Web lets you run Claude Code in your browser. It analyzes and edits code on an Anthropic-managed cloud VM, and you can review the changes in a diff view and open a PR right away.

Key Characteristics

	Claude Code on the Web	Local CLI
Where it runs	Anthropic cloud VM	Your computer
Installation	None (browser only)	npm install required
Local file access	No (GitHub integration)	Yes
Parallel work	Multiple at once	1 per CLI instance
MCP servers	Limited	Fully supported
Git integration	GitHub only	Any Git

Plan Availability

Plan	Available
Pro	O
Max	O
Team	O
Enterprise	Premium or Chat+Claude Code seat

Getting Started

1. Visit claude.ai/code
2. Connect your GitHub account
3. Install the Claude GitHub app on your repository
4. Choose a default environment
5. Submit a coding task
6. Review the changes in the diff view → create a PR

How It Works

1. Clone the repository onto a cloud VM
2. Prepare a secure environment (dependencies, network settings)
3. Analyze code, make changes, run tests
4. Notify on completion
5. Push to a branch → ready to create a PR

Claude Code respects your CLAUDE.md context, and SessionStart hooks run as well.

Diff View

The web interface shows changes in a GitHub-style diff view:

• Displays diff stats (+/- line counts)
• Review changes file by file
• Comment on specific changes
• Iterate on the review without a draft PR

Switching Between Web and Terminal

Terminal → Web (--remote)

# Run a task on the web
claude --remote "Fix the auth bug in src/auth/login.ts"

• Creates a new web session on claude.ai
• The task runs in the cloud while you keep working locally
• Check progress with /tasks
• Give feedback from claude.ai or the mobile app

# Parallel runs work too — each --remote is an independent session
claude --remote "Refactor the API endpoints"
claude --remote "Improve test coverage"

Plan locally first

It's efficient to explore the code locally with --permission-mode plan first, then delegate the actual work to the web with --remote.

Web → Terminal (/teleport)

You can pull work done on the web back into your local terminal:

# Interactive session picker
> /teleport
# Or the short form
> /tp

# Directly from the CLI
claude --teleport
claude --teleport <session-id>

You can also press t in /tasks to teleport, or use the "Open in CLI" button in the web interface.

Teleport requirements:

Condition	Description
Clean git state	You get a stash prompt if you have uncommitted changes
Same repository	Must run in the same repo, not a fork
Branch available	The branch must be pushed to the remote (auto fetch+checkout)
Same account	Authenticated with the same claude.ai account

Session Sharing

Plan	Sharing scope
Enterprise/Team	Private or Team (visible to organization members)
Max/Pro	Private or Public (visible to any logged-in user)

Repository access is verified for Team/Public sharing. You can enable access verification and hide names under Settings → Claude Code → Sharing settings.

Cloud Environment Configuration

Default Environment

Key tools included in the default image:

Category	Included tools
Languages	Python 3.x, Node.js LTS, Ruby 3.3, PHP 8.4, Java (OpenJDK), Go, Rust, C++
Package managers	pip, poetry, npm, yarn, pnpm, bun, gem, bundler, cargo, Maven, Gradle
Databases	PostgreSQL 16, Redis 7.0

Use the check-tools command to see what's available.

Custom Environments

To add or modify environments:

• In the web UI, select the current environment → "Add environment" or the settings button
• Specify a name, network access, and environment variables
• From the terminal, choose the default environment with /remote-env

Installing Dependencies

Use a SessionStart hook to install dependencies automatically when a cloud session starts:

// .claude/settings.json
{
  "hooks": {
    "SessionStart": [
      {
        "matcher": "startup",
        "hooks": [
          {
            "type": "command",
            "command": "\"$CLAUDE_PROJECT_DIR\"/scripts/install_pkgs.sh"
          }
        ]
      }
    ]
  }
}

#!/bin/bash
# scripts/install_pkgs.sh
# Run only in the cloud environment
if [ "$CLAUDE_CODE_REMOTE" != "true" ]; then
  exit 0
fi
npm install
pip install -r requirements.txt
exit 0

Dependency management limitations

• Hooks run in every session. Check the CLAUDE_CODE_REMOTE variable to skip local runs
• Network access is required to reach package registries
• Some package managers (Bun, for example) may not be compatible with the security proxy

Network and Security

Network Policy

• GitHub proxy: Handles all git interactions transparently, using scope-limited credentials inside the sandbox
• Security proxy: All outbound traffic passes through the proxy. Blocks malicious requests, applies rate limiting and content filtering
• git push restriction: You can only push to the current working branch

Access Levels

Level	Description
Default	Only allowlisted domains are reachable
Custom	Disable network access entirely, or allow only specific domains

The default allowlist includes Anthropic services, GitHub/GitLab/Bitbucket, major package registries (npm, PyPI, RubyGems, crates.io, Maven, and others), cloud platforms (AWS, GCP, Azure), and container registries.

Security Isolation

• Each session runs in an isolated VM
• Sensitive credentials never exist inside the sandbox
• Authentication goes through the security proxy

Note on disabling network access

Even with network access disabled, Claude Code can still communicate with the Anthropic API, which means data can leave the isolated VM through that channel.

Limitations

Limitation	Description
GitHub only	GitLab and non-GitHub repositories aren't supported
Session authentication	Switching between web and local requires the same account
Shared rate limit	Shares the rate limit with all other Claude usage on your account

Best Practices

1. Use SessionStart hooks: Automate environment setup and dependency installation
2. Document your requirements: Spell out dependencies and commands in CLAUDE.md
3. Plan locally, execute on the web: Explore complex work in Plan mode first
4. Take advantage of parallelism: Run several independent tasks at once with --remote