llms.txt@01-Getting-Started git:20260521.1b74b3eF

Immutable. This exact content never changes and is served at /api/v1/blob/026f6737367a55a3.

# Getting Started

All documentation for Getting Started.


---
## advanced-setup-claude-code-docs-0526bc1300.md

# Advanced setup


System requirements, platform-specific installation, version management, and uninstallation for Claude Code.


This page covers system requirements, platform-specific installation details, updates, and uninstallation. For a guided walkthrough of your first session, see the [quickstart](/docs/en/quickstart). If you’ve never used a terminal before, see the [terminal guide](/docs/en/terminal-guide).


[​](#system-requirements)

System requirements

Claude Code runs on the following platforms and configurations:

- **Operating system**:
  - macOS 13.0+
  - Windows 10 1809+ or Windows Server 2019+
  - Ubuntu 20.04+
  - Debian 10+
  - Alpine Linux 3.19+
- **Hardware**: 4 GB+ RAM, x64 or ARM64 processor
- **Network**: internet connection required. See [network configuration](/docs/en/network-config#network-access-requirements).
- **Shell**: Bash, Zsh, PowerShell, or CMD. Native Windows setups require [Git for Windows](https://git-scm.com/downloads/win). WSL setups do not.
- **Location**: [Anthropic supported countries](https://www.anthropic.com/supported-countries)


[​](#additional-dependencies)

Additional dependencies

- **ripgrep**: usually included with Claude Code. If search fails, see [search troubleshooting](/docs/en/troubleshooting#search-and-discovery-issues).


[​](#install-claude-code)

Install Claude Code

Prefer a graphical interface? The [Desktop app](/docs/en/desktop-quickstart) lets you use Claude Code without the terminal. Download it for [macOS](https://claude.ai/api/desktop/darwin/universal/dmg/latest/redirect?utm_source=claude_code&utm_medium=docs) or [Windows](https://claude.com/download?utm_source=claude_code&utm_medium=docs).New to the terminal? See the [terminal guide](/docs/en/terminal-guide) for step-by-step instructions.

To install Claude Code, use one of the following methods:

- Native Install (Recommended)

- Homebrew

- WinGet

**macOS, Linux, WSL:**

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

**Windows PowerShell:**

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

**Windows CMD:**

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

If you see `The token '&&' is not a valid statement separator`, you’re in PowerShell, not CMD. If you see `'irm' is not recognized as an internal or external command`, you’re in CMD, not PowerShell. Your prompt shows `PS C:\` when you’re in PowerShell and `C:\` without the `PS` when you’re in CMD.**Native Windows setups require [Git for Windows](https://git-scm.com/downloads/win).** Install it first if you don’t have it. WSL setups do not need it.

Native installations automatically update in the background to keep you on the latest version.

```python
brew install --cask claude-code
```

Homebrew offers two casks. `claude-code` tracks the stable release channel, which is typically about a week behind and skips releases with major regressions. `claude-code@latest` tracks the latest channel and receives new versions as soon as they ship.

Homebrew installations do not auto-update. Run `brew upgrade claude-code` or `brew upgrade claude-code@latest`, depending on which cask you installed, to get the latest features and security fixes.

```python
winget install Anthropic.ClaudeCode
```

WinGet installations do not auto-update. Run `winget upgrade Anthropic.ClaudeCode` periodically to get the latest features and security fixes.

You can also install with [apt, dnf, or apk](/docs/en/setup#install-with-linux-package-managers) on Debian, Fedora, RHEL, and Alpine. After installation completes, open a terminal in the project you want to work in and start Claude Code:

```python
claude
```

If you encounter any issues during installation, see the [troubleshooting guide](/docs/en/troubleshooting).


[​](#set-up-on-windows)

Set up on Windows

You can run Claude Code natively on Windows or inside WSL. Pick based on where your projects are located and which features you need:

| Option | Requires | [Sandboxing](/docs/en/sandboxing) | When to use |
|----|----|----|----|
| Native Windows | [Git for Windows](https://git-scm.com/downloads/win) | Not supported | Windows-native projects and tools |
| WSL 2 | WSL 2 enabled | Supported | Linux toolchains or sandboxed command execution |
| WSL 1 | WSL 1 enabled | Not supported | If WSL 2 is unavailable |

**Option 1: Native Windows with Git Bash** Install [Git for Windows](https://git-scm.com/downloads/win), then run the install command from PowerShell or CMD. You do not need to run as Administrator. Whether you install from PowerShell or CMD only affects which install command you run. Your prompt shows `PS C:\Users\YourName>` in PowerShell and `C:\Users\YourName>` without the `PS` in CMD. If you’re new to the terminal, the [terminal guide](/docs/en/terminal-guide#windows) walks through each step. After installation, launch `claude` from PowerShell, CMD, or Git Bash. Claude Code uses Git Bash internally to execute commands regardless of where you launched it. If Claude Code can’t find your Git Bash installation, set the path in your [settings.json file](/docs/en/settings):

```python
{
  "env": {
    "CLAUDE_CODE_GIT_BASH_PATH": "C:\\Program Files\\Git\\bin\\bash.exe"
  }
}
```

Claude Code can also run PowerShell natively on Windows. The PowerShell tool is rolling out progressively; set `CLAUDE_CODE_USE_POWERSHELL_TOOL=1` to opt in or `0` to opt out. See [PowerShell tool](/docs/en/tools-reference#powershell-tool) for setup and limitations. **Option 2: WSL** Open your WSL distribution and run the Linux installer from the [install instructions](#install-claude-code) above. You install and launch `claude` inside the WSL terminal, not from PowerShell or CMD.


[​](#alpine-linux-and-musl-based-distributions)

Alpine Linux and musl-based distributions

The native installer on Alpine and other musl/uClibc-based distributions requires `libgcc`, `libstdc++`, and `ripgrep`. Install these using your distribution’s package manager, then set `USE_BUILTIN_RIPGREP=0`. This example installs the required packages on Alpine:

```python
apk add libgcc libstdc++ ripgrep
```

Then set `USE_BUILTIN_RIPGREP` to `0` in your [`settings.json`](/docs/en/settings#available-settings) file:

```python
{
  "env": {
    "USE_BUILTIN_RIPGREP": "0"
  }
}
```


[​](#verify-your-installation)

Verify your installation

After installing, confirm Claude Code is working:

```python
claude --version
```

For a more detailed check of your installation and configuration, run [`claude doctor`](/docs/en/troubleshooting#get-more-help):

```python
claude doctor
```


[​](#authenticate)

Authenticate

Claude Code requires a Pro, Max, Team, Enterprise, or Console account. The free Claude.ai plan does not include Claude Code access. You can also use Claude Code with a third-party API provider like [Amazon Bedrock](/docs/en/amazon-bedrock), [Google Vertex AI](/docs/en/google-vertex-ai), or [Microsoft Foundry](/docs/en/microsoft-foundry). After installing, log in by running `claude` and following the browser prompts. See [Authentication](/docs/en/authentication) for all account types and team setup options.


[​](#update-claude-code)

Update Claude Code

Native installations automatically update in the background. You can [configure the release channel](#configure-release-channel) to control whether you receive updates immediately or on a delayed stable schedule, or [disable auto-updates](#disable-auto-updates) entirely. Homebrew, WinGet, and [Linux package manager](#install-with-linux-package-managers) installations require manual updates.


[​](#auto-updates)

Auto-updates

Claude Code checks for updates on startup and periodically while running. Updates download and install in the background, then take effect the next time you start Claude Code.

Homebrew, WinGet, apt, dnf, and apk installations do not auto-update. For Homebrew, run `brew upgrade claude-code` or `brew upgrade claude-code@latest`, depending on which cask you installed. For WinGet, run `winget upgrade Anthropic.ClaudeCode`. For Linux package managers, see the upgrade commands in [Install with Linux package managers](#install-with-linux-package-managers).**Known issue:** Claude Code may notify you of updates before the new version is available in these package managers. If an upgrade fails, wait and try again later.Homebrew keeps old versions on disk after upgrades. Run `brew cleanup` periodically to reclaim disk space.


[​](#configure-release-channel)

Configure release channel

Control which release channel Claude Code follows for auto-updates and `claude update` with the `autoUpdatesChannel` setting:

- `"latest"`, the default: receive new features as soon as they’re released
- `"stable"`: use a version that is typically about one week old, skipping releases with major regressions

Configure this via `/config` → **Auto-update channel**, or add it to your [settings.json file](/docs/en/settings):

```python
{
  "autoUpdatesChannel": "stable"
}
```

For enterprise deployments, you can enforce a consistent release channel across your organization using [managed settings](/docs/en/permissions#managed-settings). Homebrew installations choose a channel by cask name instead of this setting: `claude-code` tracks stable and `claude-code@latest` tracks latest.


[​](#pin-a-minimum-version)

Pin a minimum version

The `minimumVersion` setting establishes a floor. Background auto-updates and `claude update` refuse to install any version below this value, so moving to the `"stable"` channel does not downgrade you if you are already on a newer `"latest"` build. Switching from `"latest"` to `"stable"` via `/config` prompts you to either stay on the current version or allow the downgrade. Choosing to stay sets `minimumVersion` to that version. Switching back to `"latest"` clears it. Add it to your [settings.json file](/docs/en/settings) to pin a floor explicitly:

```python
{
  "autoUpdatesChannel": "stable",
  "minimumVersion": "2.1.100"
}
```

In [managed settings](/docs/en/permissions#managed-settings), this enforces an organization-wide minimum that user and project settings cannot override.


[​](#disable-auto-updates)

Disable auto-updates

Set `DISABLE_AUTOUPDATER` to `"1"` in the `env` key of your [`settings.json`](/docs/en/settings#available-settings) file:

```python
{
  "env": {
    "DISABLE_AUTOUPDATER": "1"
  }
}
```

`DISABLE_AUTOUPDATER` only stops the background check; `claude update` and `claude install` still work. To block all update paths, including manual updates, set [`DISABLE_UPDATES`](/docs/en/env-vars) instead. Use this when you distribute Claude Code through your own channels and need users to stay on the version you provide.


[​](#update-manually)

Update manually

To apply an update immediately without waiting for the next background check, run:

```python
claude update
```


[​](#advanced-installation-options)

Advanced installation options

These options are for version pinning, Linux package managers, npm, and verifying binary integrity.


[​](#install-a-specific-version)

Install a specific version

The native installer accepts either a specific version number or a release channel (`latest` or `stable`). The channel you choose at install time becomes your default for auto-updates. See [configure release channel](#configure-release-channel) for more information. To install the latest version (default):

- macOS, Linux, WSL

- Windows PowerShell

- Windows CMD

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

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

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

To install the stable version:

- macOS, Linux, WSL

- Windows PowerShell

- Windows CMD

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

```python
& ([scriptblock]::Create((irm https://claude.ai/install.ps1))) stable
```

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

To install a specific version number:

- macOS, Linux, WSL

- Windows PowerShell

- Windows CMD

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

```python
& ([scriptblock]::Create((irm https://claude.ai/install.ps1))) 2.1.89
```

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


[​](#install-with-linux-package-managers)

Install with Linux package managers

Claude Code publishes signed apt, dnf, and apk repositories. Replace `stable` with `latest` for the rolling channel. Package manager installations do not auto-update through Claude Code; updates arrive through your normal system upgrade workflow. All repositories are signed with the [Claude Code release signing key](#binary-integrity-and-code-signing). Before trusting the key, verify it as described in each tab.

- apt

- dnf

- apk

For Debian and Ubuntu. To use the rolling channel, change both `stable` occurrences in the `deb` line: the URL path and the suite name.

```python
sudo install -d -m 0755 /etc/apt/keyrings
sudo curl -fsSL https://downloads.claude.ai/keys/claude-code.asc \
  -o /etc/apt/keyrings/claude-code.asc
echo "deb [signed-by=/etc/apt/keyrings/claude-code.asc] https://downloads.claude.ai/claude-code/apt/stable stable main" \
  | sudo tee /etc/apt/sources.list.d/claude-code.list
sudo apt update
sudo apt install claude-code
```

Verify the GPG key fingerprint before trusting it: `gpg --show-keys /etc/apt/keyrings/claude-code.asc` should report `31DD DE24 DDFA B679 F42D 7BD2 BAA9 29FF 1A7E CACE`.To upgrade later, run `sudo apt update && sudo apt upgrade claude-code`.

For Fedora and RHEL:

```python
sudo tee /etc/yum.repos.d/claude-code.repo <<'EOF'
[claude-code]
name=Claude Code
baseurl=https://downloads.claude.ai/claude-code/rpm/stable
enabled=1
gpgcheck=1
gpgkey=https://downloads.claude.ai/keys/claude-code.asc
EOF
sudo dnf install claude-code
```

dnf downloads the key on first install and prompts you to confirm the fingerprint. Verify it matches `31DD DE24 DDFA B679 F42D 7BD2 BAA9 29FF 1A7E CACE` before accepting.To upgrade later, run `sudo dnf upgrade claude-code`.

For Alpine Linux:

```python
wget -O /etc/apk/keys/claude-code.rsa.pub \
  https://downloads.claude.ai/keys/claude-code.rsa.pub
echo "https://downloads.claude.ai/claude-code/apk/stable" >> /etc/apk/repositories
apk add claude-code
```

Verify the downloaded key with `sha256sum /etc/apk/keys/claude-code.rsa.pub`, which should report `395759c1f7449ef4cdef305a42e820f3c766d6090d142634ebdb049f113168b6`.To upgrade later, run `apk update && apk upgrade claude-code`.


[​](#install-with-npm)

Install with npm

You can also install Claude Code as a global npm package. The package requires [Node.js 18 or later](https://nodejs.org/en/download).

```python
npm install -g @anthropic-ai/claude-code
```

The npm package installs the same native binary as the standalone installer. npm pulls the binary in through a per-platform optional dependency such as `@anthropic-ai/claude-code-darwin-arm64`, and a postinstall step links it into place. The installed `claude` binary does not itself invoke Node. Supported npm install platforms are `darwin-arm64`, `darwin-x64`, `linux-x64`, `linux-arm64`, `linux-x64-musl`, `linux-arm64-musl`, `win32-x64`, and `win32-arm64`. Your package manager must allow optional dependencies. See [troubleshooting](/docs/en/troubleshooting#native-binary-not-found-after-npm-install) if the binary is missing after install.

Do NOT use `sudo npm install -g` as this can lead to permission issues and security risks. If you encounter permission errors, see [troubleshooting permission errors](/docs/en/troubleshooting#permission-errors-during-installation).


[​](#binary-integrity-and-code-signing)

Binary integrity and code signing

Each release publishes a `manifest.json` containing SHA256 checksums for every platform binary. The manifest is signed with an Anthropic GPG key, so verifying the signature on the manifest transitively verifies every binary it lists.


[​](#verify-the-manifest-signature)

Verify the manifest signature

Steps 1-3 require a POSIX shell with `gpg` and `curl`. On Windows, run them in Git Bash or WSL. Step 4 includes a PowerShell option.

1


Download and import the public key

The release signing key is published at a fixed URL.

```python
curl -fsSL https://downloads.claude.ai/keys/claude-code.asc | gpg --import
```

Display the fingerprint of the imported key.

```python
gpg --fingerprint security@anthropic.com
```

Confirm the output includes this fingerprint:

```python
31DD DE24 DDFA B679 F42D  7BD2 BAA9 29FF 1A7E CACE
```

2


Download the manifest and signature

Set `VERSION` to the release you want to verify.

```python
REPO=https://downloads.claude.ai/claude-code-releases
VERSION=2.1.89
curl -fsSLO "$REPO/$VERSION/manifest.json"
curl -fsSLO "$REPO/$VERSION/manifest.json.sig"
```

3


Verify the signature

Verify the detached signature against the manifest.

```python
gpg --verify manifest.json.sig manifest.json
```

A valid result reports `Good signature from "Anthropic Claude Code Release Signing <security@anthropic.com>"`.`gpg` also prints `WARNING: This key is not certified with a trusted signature!` for any freshly imported key. This is expected. The `Good signature` line confirms the cryptographic check passed. The fingerprint comparison in Step 1 confirms the key itself is authentic.

4


Check the binary against the manifest

Compare the SHA256 checksum of your downloaded binary with the value listed under `platforms.<platform>.checksum` in `manifest.json`.

- Linux

- macOS

- Windows PowerShell

```python
sha256sum claude
```

```python
shasum -a 256 claude
```

```python
(Get-FileHash claude.exe -Algorithm SHA256).Hash.ToLower()
```

Manifest signatures are available for releases from `2.1.89` onward. Earlier releases publish checksums in `manifest.json` without a detached signature.


[​](#platform-code-signatures)

Platform code signatures

In addition to the signed manifest, individual binaries carry platform-native code signatures where supported.

- **macOS**: signed by “Anthropic PBC” and notarized by Apple. Verify with `codesign --verify --verbose ./claude`.
- **Windows**: signed by “Anthropic, PBC”. Verify with `Get-AuthenticodeSignature .\claude.exe`.
- **Linux**: binaries are not individually code-signed. If you download directly from the `claude-code-releases` bucket or use the native installer, verify integrity with the manifest signature above. If you install with [apt, dnf, or apk](#install-with-linux-package-managers), your package manager verifies signatures automatically using the repository signing key.


[​](#uninstall-claude-code)

Uninstall Claude Code

To remove Claude Code, follow the instructions for your installation method.


[​](#native-installation)

Native installation

Remove the Claude Code binary and version files:

- macOS, Linux, WSL

- Windows PowerShell

```python
rm -f ~/.local/bin/claude
rm -rf ~/.local/share/claude
```

```python
Remove-Item -Path "$env:USERPROFILE\.local\bin\claude.exe" -Force
Remove-Item -Path "$env:USERPROFILE\.local\share\claude" -Recurse -Force
```


[​](#homebrew-installation)

Homebrew installation

Remove the Homebrew cask you installed. If you installed the stable cask:

```python
brew uninstall --cask claude-code
```

If you installed the latest cask:

```python
brew uninstall --cask claude-code@latest
```


[​](#winget-installation)

WinGet installation

Remove the WinGet package:

```python
winget uninstall Anthropic.ClaudeCode
```


[​](#apt-/-dnf-/-apk)

apt / dnf / apk

Remove the package and the repository configuration:

- apt

- dnf

- apk

```python
sudo apt remove claude-code
sudo rm /etc/apt/sources.list.d/claude-code.list /etc/apt/keyrings/claude-code.asc
```

```python
sudo dnf remove claude-code
sudo rm /etc/yum.repos.d/claude-code.repo
```

```python
apk del claude-code
sed -i '\|downloads.claude.ai/claude-code/apk|d' /etc/apk/repositories
rm /etc/apk/keys/claude-code.rsa.pub
```


[​](#npm)

npm

Remove the global npm package:

```python
npm uninstall -g @anthropic-ai/claude-code
```


[​](#remove-configuration-files)

Remove configuration files

Removing configuration files will delete all your settings, allowed tools, MCP server configurations, and session history.

The VS Code extension, the JetBrains plugin, and the Desktop app also write to `~/.claude/`. If any of them is still installed, the directory is recreated the next time it runs. To remove Claude Code completely, uninstall the [VS Code extension](/docs/en/vs-code#uninstall-the-extension), the JetBrains plugin, and the Desktop app before deleting these files. To remove Claude Code settings and cached data:

- macOS, Linux, WSL

- Windows PowerShell

```python
# Remove user settings and state
rm -rf ~/.claude
rm ~/.claude.json

# Remove project-specific settings (run from your project directory)
rm -rf .claude
rm -f .mcp.json
```

```python
# Remove user settings and state
Remove-Item -Path "$env:USERPROFILE\.claude" -Recurse -Force
Remove-Item -Path "$env:USERPROFILE\.claude.json" -Force

# Remove project-specific settings (run from your project directory)
Remove-Item -Path ".claude" -Recurse -Force
Remove-Item -Path ".mcp.json" -Force
```


---
## claude-api-monitoring-quickstart.md

# Claude API Monitoring - Quick Start

## Installation Complete

All components have been configured:

1. **MITMproxy Logger**: `~/.local/bin/claude-api-logger.py`
   - Stealth mode enabled (read-only, no traffic modification)
   - Logs to: `~/.claude/api-logs/`
   - Redacts sensitive headers in logs

2. **Proxy Launcher**: `~/.local/bin/start-claude-proxy`
   - Runs on port 8888 by default (avoids interfering with normal web traffic)
   - Quiet mode for minimal output
   - Streams large bodies efficiently

3. **Monitoring Dashboard**: `~/.local/bin/start-claude-monitoring`
   - Starts both terminal viewer and proxy
   - One-command setup

4. **Terminal Viewer**: Updated at `/home/zack/dev/claude-terminal-viewer`
   - New "API Calls" filter
   - Orange badges for API logs
   - JSON-formatted display

## Quick Start (3 Steps)

### 1. Install MITMproxy CA Certificate

**First time only:**

```bash
# Start proxy to generate certificates
start-claude-proxy
# Press Ctrl+C after a few seconds

# Install certificate (Arch Linux)
sudo trust anchor --store ~/.mitmproxy/mitmproxy-ca-cert.pem

# Verify
trust list | grep -i mitmproxy
```

### 2. Start Monitoring

**Option A - All-in-one (recommended):**
```bash
start-claude-monitoring
```

**Option B - Individual components:**
```bash
# Terminal 1: Start viewer
cd ~/dev/claude-terminal-viewer && npm run dev -- --port 3001

# Terminal 2: Start proxy
start-claude-proxy
```

### 3. Configure Application to Use Proxy

**For Claude Desktop or any application:**

```bash
HTTP_PROXY=http://localhost:8888 \
HTTPS_PROXY=http://localhost:8888 \
NODE_EXTRA_CA_CERTS="$HOME/.mitmproxy/mitmproxy-ca-cert.pem" \
claude-desktop
```

**Or create a launcher script:**
```bash
#!/usr/bin/env bash
# ~/.local/bin/claude-desktop-monitored

export HTTP_PROXY="http://localhost:8888"
export HTTPS_PROXY="http://localhost:8888"
export NODE_EXTRA_CA_CERTS="$HOME/.mitmproxy/mitmproxy-ca-cert.pem"

exec /usr/bin/claude-desktop "$@"
```

Make it executable:
```bash
chmod +x ~/.local/bin/claude-desktop-monitored
```

## Viewing Logs

1. Open browser: http://localhost:3001
2. Select filter: "API Calls Only"
3. Click any API call to view full request/response

## Stealth Features

The setup is designed to be transparent:

- **No traffic modification**: Logs only, never alters requests/responses
- **Quiet operation**: Minimal console output
- **Sensitive data handling**: API keys redacted in logs (first 4 + last 4 chars)
- **Fail-safe**: Errors don't break connections
- **Efficient streaming**: Large responses handled properly

## Troubleshooting

### No logs appearing?

```bash
# Check proxy is running
netstat -tulpn | grep 8888

# Check log directory
ls -la ~/.claude/api-logs/

# Check if app is using proxy
ss -tunap | grep ESTABLISHED | grep 8888
```

### Certificate errors?

```bash
# Regenerate certificates
rm -rf ~/.mitmproxy
start-claude-proxy  # Run and stop with Ctrl+C
sudo trust anchor --store ~/.mitmproxy/mitmproxy-ca-cert.pem
```

### Terminal viewer not showing API logs?

```bash
# Restart viewer
cd ~/dev/claude-terminal-viewer
npm run dev -- --port 3001
```

## Architecture Analysis

Once running, you can:

1. **Inspect Request Structure**: See how Claude API requests are formatted
2. **Monitor Token Usage**: Track token consumption per request
3. **Debug API Issues**: View exact error responses
4. **Understand Session Flow**: See how conversations are maintained
5. **Rate Limit Monitoring**: Track API usage patterns

## Security Notes

- Logs contain API keys (redacted, but still sensitive)
- Set proper permissions: `chmod 600 ~/.claude/api-logs/*`
- Development use only
- Keep MITMproxy certificate secure

## Advanced Usage

### Custom Proxy Port

```bash
CLAUDE_PROXY_PORT=9090 start-claude-monitoring
```

### Verbose Logging

```bash
start-claude-proxy --set console_eventlog_verbosity=debug
```

### Filter Specific Endpoints

Edit `~/.local/bin/claude-api-logger.py` and modify the host check:

```python
if "api.anthropic.com" in flow.request.pretty_host:
    # Only log API calls, not web traffic
```

## Full Documentation

See: `/home/zack/dev/claude-api-monitoring-setup.md`

---

**Ready to monitor!** Run `start-claude-monitoring` to begin.


---
## claude-code-monitoring-complete.md

# Claude Code API Monitoring - Complete Setup

## Overview

Your Claude Code CLI is now configured to route through MITMproxy with **real-time ping/pong visibility**. You'll see every API request and response as they happen, with detailed timing and token usage information.

## What's Configured

### 1. Enhanced API Logger
Location: `~/.local/bin/claude-api-logger.py`

**New Features:**
- **Request Tracking**: Each request gets a unique ID
- **PING/PONG Display**: Real-time console output showing:
  - → PING: Outgoing requests with model info
  - ← PONG: Responses with status, timing, and token usage
- **Response Time**: Measures exact milliseconds for each API call
- **Token Metrics**: Shows input/output token counts
- **Dual Logging**:
  - Detailed JSONL logs: `~/.claude/api-logs/session_*.jsonl`
  - Real-time log: `~/.claude/api-logs/realtime.log`

### 2. Antigravity Integration
Your existing setup at `/home/zack/dev/antigravityresearch/launch-claude-code.sh` routes Claude Code through MITMproxy using cgroups.

### 3. Terminal Viewer
Already running at http://localhost:3001 - now includes API call filtering.

## How to Use

### Start Monitoring

```bash
# Terminal 1: Start the monitoring proxy
start-claude-monitoring
```

This will show real-time output like:
```
[15:30:45.123] → PING #1 | POST /v1/messages | Model: claude-opus-4-20250514
[15:30:47.456] ← PONG #1 ✓ | 200 | 2333ms | Tokens: in:1234 out:5678
[15:30:50.789] → PING #2 | POST /v1/messages | Model: claude-sonnet-4-5-20250929
[15:30:51.012] ← PONG #2 ✓ | 200 | 223ms | Tokens: in:890 out:1234
```

### Launch Claude Code

```bash
# Terminal 2: Normal claude alias (already configured)
claude
```

Your alias runs `/home/zack/dev/antigravityresearch/launch-claude-code.sh` which:
1. Starts antigravity-proxy service if needed
2. Adds process to cgroup for transparent routing
3. Sets NODE_EXTRA_CA_CERTS for MITMproxy
4. Launches Claude Code

### View in Terminal Viewer

Open http://localhost:3001
- Filter by "API Calls Only"
- See full JSON request/response details
- Browse by timestamp

## Real-Time Output Format

### PING (Request)
```
→ PING #<id> | <METHOD> <PATH> | Model: <model-name>
```

Example:
```
→ PING #5 | POST /v1/messages | Model: claude-opus-4-20250514
```

### PONG (Response)
```
← PONG #<id> <status-icon> | <status-code> | <response-time>ms | Tokens: in:<input> out:<output>
```

Examples:
```
← PONG #5 ✓ | 200 | 1845ms | Tokens: in:2340 out:8721
← PONG #6 ✗ | 429 | 120ms
```

Status icons:
- ✓ = Success (200-399)
- ✗ = Error (400+)

## Log Files

### JSONL Logs (Detailed)
```bash
# Latest session
ls -ltr ~/.claude/api-logs/session_*.jsonl | tail -1

# View latest requests
tail -50 ~/.claude/api-logs/session_$(date +%Y%m%d)_*.jsonl | jq .
```

### Real-Time Log
```bash
# Watch live
tail -f ~/.claude/api-logs/realtime.log

# Today's traffic
cat ~/.claude/api-logs/realtime.log
```

## Example Session Output

```
[15:30:45.123] → PING #1 | POST /v1/messages | Model: claude-opus-4-20250514
[15:30:47.456] ← PONG #1 ✓ | 200 | 2333ms | Tokens: in:1234 out:5678

[15:30:50.789] → PING #2 | POST /v1/messages | Model: claude-opus-4-20250514
[15:30:52.901] ← PONG #2 ✓ | 200 | 2112ms | Tokens: in:5678 out:12340

[15:31:00.123] → PING #3 | POST /v1/messages | Model: claude-sonnet-4-5-20250929
[15:31:00.456] ← PONG #3 ✓ | 200 | 333ms | Tokens: in:1000 out:2000
```

## Understanding the Data

### Request ID
Sequential counter for matching requests to responses.

### Response Time
- Measured in milliseconds
- Starts when request is sent
- Ends when response is received
- Includes network latency + API processing time

### Token Usage
- **Input tokens**: Your prompt + context
- **Output tokens**: Claude's response
- Only shown for successful responses with usage data

## What You Can See

### 1. Model Selection
See which model (Opus, Sonnet, Haiku) is being used for each request.

### 2. API Patterns
- How often requests are made
- Which endpoints are called
- Request/response timing

### 3. Token Consumption
- Real-time token usage
- Compare token efficiency across models
- Track cumulative usage

### 4. Performance Metrics
- Response times per model
- Network latency
- API processing time

### 5. Error Patterns
- Rate limits (429)
- Authentication issues (401, 403)
- Server errors (500+)

## Advanced Usage

### Filter by Model in Logs

```bash
# Only Opus calls
grep "claude-opus" ~/.claude/api-logs/realtime.log

# Only Sonnet calls
grep "claude-sonnet" ~/.claude/api-logs/realtime.log
```

### Calculate Average Response Time

```bash
# Extract response times
grep "PONG" ~/.claude/api-logs/realtime.log | \
  grep -oP '\d+ms' | \
  sed 's/ms//' | \
  awk '{sum+=$1; count++} END {print "Average:", sum/count, "ms"}'
```

### Total Token Usage

```bash
# Parse JSONL for usage stats
cat ~/.claude/api-logs/session_*.jsonl | \
  jq -s '[.[] | select(.type=="response" and .body.usage) | .body.usage] | {
    total_input: map(.input_tokens) | add,
    total_output: map(.output_tokens) | add
  }'
```

## Troubleshooting

### No PING/PONG output?

1. Check proxy is running:
   ```bash
   ps aux | grep mitmdump
   ```

2. Check Claude is using proxy:
   ```bash
   ps aux | grep claude | grep -v grep
   # Should see process in cgroup
   ```

3. Check logs are being written:
   ```bash
   ls -ltr ~/.claude/api-logs/
   ```

### Logs but no real-time output?

Check console log file:
```bash
tail -f ~/.claude/api-logs/realtime.log
```

If file exists but terminal shows nothing, the output is being written to the log file but not stdout (this is normal in background mode).

### Timing seems off?

Response time is measured from when MITMproxy sees the request until it sees the response. This includes:
- Network latency to Anthropic servers
- API processing time
- Streaming delay (if applicable)

## Port Configuration

- **Terminal Viewer**: Port 3001
- **MITMproxy**: Port 8888 (isolated from normal web traffic)
- **Antigravity Service**: Uses cgroups for transparent routing

## Benefits of This Setup

1. **Complete Visibility**: See every API interaction
2. **Real-Time Feedback**: Immediate ping/pong display
3. **Performance Monitoring**: Track response times
4. **Token Tracking**: Monitor usage and costs
5. **Debugging**: Inspect full request/response details
6. **Architecture Understanding**: Learn Claude API patterns
7. **Model Comparison**: Compare Opus vs Sonnet performance

## Next Steps

1. **Start monitoring**: `start-claude-monitoring`
2. **Use Claude normally**: `claude`
3. **Watch the ping/pong**: See real-time API traffic
4. **Analyze patterns**: Review logs and metrics
5. **Optimize usage**: Use insights to improve efficiency

---

**Status**: ✅ Complete and ready
**Real-time logs**: `tail -f ~/.claude/api-logs/realtime.log`
**Web viewer**: http://localhost:3001
**Current model**: Check PING messages for model info

The setup is completely transparent - Claude Code works normally while you get full visibility into every API call!


---
## discover-plugins.md

> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Discover and install prebuilt plugins through marketplaces

> Find and install plugins from marketplaces to extend Claude Code with new commands, agents, and capabilities.

Plugins extend Claude Code with skills, agents, hooks, and MCP servers. Plugin marketplaces are catalogs that help you discover and install these extensions without building them yourself.

Looking to create and distribute your own marketplace? See [Create and distribute a plugin marketplace](../08-Plugins-Skills/create-and-distribute-a-plugin-marketplace-claude-code-docs-34a8f3c5e8.md).

## How marketplaces work

A marketplace is a catalog of plugins that someone else has created and shared. Using a marketplace is a two-step process:

<Steps>
  <Step title="Add the marketplace">
    This registers the catalog with Claude Code so you can browse what's available. No plugins are installed yet.
  </Step>

  <Step title="Install individual plugins">
    Browse the catalog and install the plugins you want.
  </Step>
</Steps>

Think of it like adding an app store: adding the store gives you access to browse its collection, but you still choose which apps to download individually.

## Official Anthropic marketplace

The official Anthropic marketplace (`claude-plugins-official`) is automatically available when you start Claude Code. Run `/plugin` and go to the **Discover** tab to browse what's available.

To install a plugin from the official marketplace:

```shell  theme={null}
/plugin install plugin-name@claude-plugins-official
```

<Note>
  The official marketplace is maintained by Anthropic. To distribute your own plugins, [create your own marketplace](../08-Plugins-Skills/create-and-distribute-a-plugin-marketplace-claude-code-docs-34a8f3c5e8.md) and share it with users.
</Note>

The official marketplace includes several categories of plugins:

### Code intelligence

Code intelligence plugins enable Claude Code's built-in LSP tool, giving Claude the ability to jump to definitions, find references, and see type errors immediately after edits. These plugins configure [Language Server Protocol](https://microsoft.github.io/language-server-protocol/) connections, the same technology that powers VS Code's code intelligence.

These plugins require the language server binary to be installed on your system. If you already have a language server installed, Claude may prompt you to install the corresponding plugin when you open a project.

| Language   | Plugin              | Binary required              |
| :--------- | :------------------ | :--------------------------- |
| C/C++      | `clangd-lsp`        | `clangd`                     |
| C#         | `csharp-lsp`        | `csharp-ls`                  |
| Go         | `gopls-lsp`         | `gopls`                      |
| Java       | `jdtls-lsp`         | `jdtls`                      |
| Kotlin     | `kotlin-lsp`        | `kotlin-language-server`     |
| Lua        | `lua-lsp`           | `lua-language-server`        |
| PHP        | `php-lsp`           | `intelephense`               |
| Python     | `pyright-lsp`       | `pyright-langserver`         |
| Rust       | `rust-analyzer-lsp` | `rust-analyzer`              |
| Swift      | `swift-lsp`         | `sourcekit-lsp`              |
| TypeScript | `typescript-lsp`    | `typescript-language-server` |

You can also [create your own LSP plugin](/en/plugins-reference#lsp-servers) for other languages.

<Note>
  If you see `Executable not found in $PATH` in the `/plugin` Errors tab after installing a plugin, install the required binary from the table above.
</Note>

#### What Claude gains from code intelligence plugins

Once a code intelligence plugin is installed and its language server binary is available, Claude gains two capabilities:

* **Automatic diagnostics**: after every file edit Claude makes, the language server analyzes the changes and reports errors and warnings back automatically. Claude sees type errors, missing imports, and syntax issues without needing to run a compiler or linter. If Claude introduces an error, it notices and fixes the issue in the same turn. This requires no configuration beyond installing the plugin. You can see diagnostics inline by pressing **Ctrl+O** when the "diagnostics found" indicator appears.
* **Code navigation**: Claude can use the language server to jump to definitions, find references, get type info on hover, list symbols, find implementations, and trace call hierarchies. These operations give Claude more precise navigation than grep-based search, though availability may vary by language and environment.

If you run into issues, see [Code intelligence troubleshooting](#code-intelligence-issues).

### External integrations

These plugins bundle pre-configured [MCP servers](../06-MCP-Tools/General/connect-claude-code-to-tools-via-mcp-claude-code-docs.md) so you can connect Claude to external services without manual setup:

* **Source control**: `github`, `gitlab`
* **Project management**: `atlassian` (Jira/Confluence), `asana`, `linear`, `notion`
* **Design**: `figma`
* **Infrastructure**: `vercel`, `firebase`, `supabase`
* **Communication**: `slack`
* **Monitoring**: `sentry`

### Development workflows

Plugins that add commands and agents for common development tasks:

* **commit-commands**: Git commit workflows including commit, push, and PR creation
* **pr-review-toolkit**: Specialized agents for reviewing pull requests
* **agent-sdk-dev**: Tools for building with the Claude Agent SDK
* **plugin-dev**: Toolkit for creating your own plugins

### Output styles

Customize how Claude responds:

* **explanatory-output-style**: Educational insights about implementation choices
* **learning-output-style**: Interactive learning mode for skill building

## Try it: add the demo marketplace

Anthropic also maintains a [demo plugins marketplace](https://github.com/anthropics/claude-code/tree/main/plugins) (`claude-code-plugins`) with example plugins that show what's possible with the plugin system. Unlike the official marketplace, you need to add this one manually.

<Steps>
  <Step title="Add the marketplace">
    From within Claude Code, run the `plugin marketplace add` command for the `anthropics/claude-code` marketplace:

    ```shell  theme={null}
    /plugin marketplace add anthropics/claude-code
    ```

    This downloads the marketplace catalog and makes its plugins available to you.
  </Step>

  <Step title="Browse available plugins">
    Run `/plugin` to open the plugin manager. This opens a tabbed interface with four tabs you can cycle through using **Tab** (or **Shift+Tab** to go backward):

    * **Discover**: browse available plugins from all your marketplaces
    * **Installed**: view and manage your installed plugins
    * **Marketplaces**: add, remove, or update your added marketplaces
    * **Errors**: view any plugin loading errors

    Go to the **Discover** tab to see plugins from the marketplace you just added.
  </Step>

  <Step title="Install a plugin">
    Select a plugin to view its details, then choose an installation scope:

    * **User scope**: install for yourself across all projects
    * **Project scope**: install for all collaborators on this repository
    * **Local scope**: install for yourself in this repository only

    For example, select **commit-commands** (a plugin that adds git workflow commands) and install it to your user scope.

    You can also install directly from the command line:

    ```shell  theme={null}
    /plugin install commit-commands@anthropics-claude-code
    ```

    See [Configuration scopes](/en/settings#configuration-scopes) to learn more about scopes.
  </Step>

  <Step title="Use your new plugin">
    After installing, the plugin's commands are immediately available. Plugin commands are namespaced by the plugin name, so **commit-commands** provides commands like `/commit-commands:commit`.

    Try it out by making a change to a file and running:

    ```shell  theme={null}
    /commit-commands:commit
    ```

    This stages your changes, generates a commit message, and creates the commit.

    Each plugin works differently. Check the plugin's description in the **Discover** tab or its homepage to learn what commands and capabilities it provides.
  </Step>
</Steps>

The rest of this guide covers all the ways you can add marketplaces, install plugins, and manage your configuration.

## Add marketplaces

Use the `/plugin marketplace add` command to add marketplaces from different sources.

<Tip>
  **Shortcuts**: You can use `/plugin market` instead of `/plugin marketplace`, and `rm` instead of `remove`.
</Tip>

* **GitHub repositories**: `owner/repo` format (for example, `anthropics/claude-code`)
* **Git URLs**: any git repository URL (GitLab, Bitbucket, self-hosted)
* **Local paths**: directories or direct paths to `marketplace.json` files
* **Remote URLs**: direct URLs to hosted `marketplace.json` files

### Add from GitHub

Add a GitHub repository that contains a `.claude-plugin/marketplace.json` file using the `owner/repo` format—where `owner` is the GitHub username or organization and `repo` is the repository name.

For example, `anthropics/claude-code` refers to the `claude-code` repository owned by `anthropics`:

```shell  theme={null}
/plugin marketplace add anthropics/claude-code
```

### Add from other Git hosts

Add any git repository by providing the full URL. This works with any Git host, including GitLab, Bitbucket, and self-hosted servers:

Using HTTPS:

```shell  theme={null}
/plugin marketplace add https://gitlab.com/company/plugins.git
```

Using SSH:

```shell  theme={null}
/plugin marketplace add git@gitlab.com:company/plugins.git
```

To add a specific branch or tag, append `#` followed by the ref:

```shell  theme={null}
/plugin marketplace add https://gitlab.com/company/plugins.git#v1.0.0
```

### Add from local paths

Add a local directory that contains a `.claude-plugin/marketplace.json` file:

```shell  theme={null}
/plugin marketplace add ./my-marketplace
```

You can also add a direct path to a `marketplace.json` file:

```shell  theme={null}
/plugin marketplace add ./path/to/marketplace.json
```

### Add from remote URLs

Add a remote `marketplace.json` file via URL:

```shell  theme={null}
/plugin marketplace add https://example.com/marketplace.json
```

<Note>
  URL-based marketplaces have some limitations compared to Git-based marketplaces. If you encounter "path not found" errors when installing plugins, see [Troubleshooting](/en/plugin-marketplaces#plugins-with-relative-paths-fail-in-url-based-marketplaces).
</Note>

## Install plugins

Once you've added marketplaces, you can install plugins directly (installs to user scope by default):

```shell  theme={null}
/plugin install plugin-name@marketplace-name
```

To choose a different [installation scope](/en/settings#configuration-scopes), use the interactive UI: run `/plugin`, go to the **Discover** tab, and press **Enter** on a plugin. You'll see options for:

* **User scope** (default): install for yourself across all projects
* **Project scope**: install for all collaborators on this repository (adds to `.claude/settings.json`)
* **Local scope**: install for yourself in this repository only (not shared with collaborators)

You may also see plugins with **managed** scope—these are installed by administrators via [managed settings](/en/settings#settings-files) and cannot be modified.

Run `/plugin` and go to the **Installed** tab to see your plugins grouped by scope.

<Warning>
  Make sure you trust a plugin before installing it. Anthropic does not control what MCP servers, files, or other software are included in plugins and cannot verify that they work as intended. Check each plugin's homepage for more information.
</Warning>

## Manage installed plugins

Run `/plugin` and go to the **Installed** tab to view, enable, disable, or uninstall your plugins. Type to filter the list by plugin name or description.

You can also manage plugins with direct commands.

Disable a plugin without uninstalling:

```shell  theme={null}
/plugin disable plugin-name@marketplace-name
```

Re-enable a disabled plugin:

```shell  theme={null}
/plugin enable plugin-name@marketplace-name
```

Completely remove a plugin:

```shell  theme={null}
/plugin uninstall plugin-name@marketplace-name
```

The `--scope` option lets you target a specific scope with CLI commands:

```shell  theme={null}
claude plugin install formatter@your-org --scope project
claude plugin uninstall formatter@your-org --scope project
```

## Manage marketplaces

You can manage marketplaces through the interactive `/plugin` interface or with CLI commands.

### Use the interactive interface

Run `/plugin` and go to the **Marketplaces** tab to:

* View all your added marketplaces with their sources and status
* Add new marketplaces
* Update marketplace listings to fetch the latest plugins
* Remove marketplaces you no longer need

### Use CLI commands

You can also manage marketplaces with direct commands.

List all configured marketplaces:

```shell  theme={null}
/plugin marketplace list
```

Refresh plugin listings from a marketplace:

```shell  theme={null}
/plugin marketplace update marketplace-name
```

Remove a marketplace:

```shell  theme={null}
/plugin marketplace remove marketplace-name
```

<Warning>
  Removing a marketplace will uninstall any plugins you installed from it.
</Warning>

### Configure auto-updates

Claude Code can automatically update marketplaces and their installed plugins at startup. When auto-update is enabled for a marketplace, Claude Code refreshes the marketplace data and updates installed plugins to their latest versions. If any plugins were updated, you'll see a notification suggesting you restart Claude Code.

Toggle auto-update for individual marketplaces through the UI:

1. Run `/plugin` to open the plugin manager
2. Select **Marketplaces**
3. Choose a marketplace from the list
4. Select **Enable auto-update** or **Disable auto-update**

Official Anthropic marketplaces have auto-update enabled by default. Third-party and local development marketplaces have auto-update disabled by default.

To disable all automatic updates entirely for both Claude Code and all plugins, set the `DISABLE_AUTOUPDATER` environment variable. See [Auto updates](/en/setup#auto-updates) for details.

To keep plugin auto-updates enabled while disabling Claude Code auto-updates, set `FORCE_AUTOUPDATE_PLUGINS=true` along with `DISABLE_AUTOUPDATER`:

```shell  theme={null}
export DISABLE_AUTOUPDATER=true
export FORCE_AUTOUPDATE_PLUGINS=true
```

This is useful when you want to manage Claude Code updates manually but still receive automatic plugin updates.

## Configure team marketplaces

Team admins can set up automatic marketplace installation for projects by adding marketplace configuration to `.claude/settings.json`. When team members trust the repository folder, Claude Code prompts them to install these marketplaces and plugins.

For full configuration options including `extraKnownMarketplaces` and `enabledPlugins`, see [Plugin settings](/en/settings#plugin-settings).

## Troubleshooting

### /plugin command not recognized

If you see "unknown command" or the `/plugin` command doesn't appear:

1. **Check your version**: Run `claude --version`. Plugins require version 1.0.33 or later.
2. **Update Claude Code**:
   * **Homebrew**: `brew upgrade claude-code`
   * **npm**: `npm update -g @anthropic-ai/claude-code`
   * **Native installer**: Re-run the install command from [Setup](advanced-setup-claude-code-docs-0526bc1300.md)
3. **Restart Claude Code**: After updating, restart your terminal and run `claude` again.

### Common issues

* **Marketplace not loading**: Verify the URL is accessible and that `.claude-plugin/marketplace.json` exists at the path
* **Plugin installation failures**: Check that plugin source URLs are accessible and repositories are public (or you have access)
* **Files not found after installation**: Plugins are copied to a cache, so paths referencing files outside the plugin directory won't work
* **Plugin skills not appearing**: Clear the cache with `rm -rf ~/.claude/plugins/cache`, restart Claude Code, and reinstall the plugin.

For detailed troubleshooting with solutions, see [Troubleshooting](/en/plugin-marketplaces#troubleshooting) in the marketplace guide. For debugging tools, see [Debugging and development tools](/en/plugins-reference#debugging-and-development-tools).

### Code intelligence issues

* **Language server not starting**: verify the binary is installed and available in your `$PATH`. Check the `/plugin` Errors tab for details.
* **High memory usage**: language servers like `rust-analyzer` and `pyright` can consume significant memory on large projects. If you experience memory issues, disable the plugin with `/plugin disable <plugin-name>` and rely on Claude's built-in search tools instead.
* **False positive diagnostics in monorepos**: language servers may report unresolved import errors for internal packages if the workspace isn't configured correctly. These don't affect Claude's ability to edit code.

## Next steps

* **Build your own plugins**: See [Plugins](../08-Plugins-Skills/create-plugins-claude-code-docs.md) to create skills, agents, and hooks
* **Create a marketplace**: See [Create a plugin marketplace](../08-Plugins-Skills/create-and-distribute-a-plugin-marketplace-claude-code-docs-34a8f3c5e8.md) to distribute plugins to your team or community
* **Technical reference**: See [Plugins reference](../08-Plugins-Skills/plugins-reference-claude-code-docs.md) for complete specifications


---
## example-settings.md

# Example Plugin Settings File

## Template: Basic Configuration

**.claude/my-plugin.local.md:**

```markdown
---
enabled: true
mode: standard
---

# My Plugin Configuration

Plugin is active in standard mode.
```

## Template: Advanced Configuration

**.claude/my-plugin.local.md:**

```markdown
---
enabled: true
strict_mode: false
max_file_size: 1000000
allowed_extensions: [".js", ".ts", ".tsx"]
enable_logging: true
notification_level: info
retry_attempts: 3
timeout_seconds: 60
custom_path: "/path/to/data"
---

# My Plugin Advanced Configuration

This project uses custom plugin configuration with:
- Standard validation mode
- 1MB file size limit
- JavaScript/TypeScript files allowed
- Info-level logging
- 3 retry attempts

## Additional Notes

Contact @team-lead with questions about this configuration.
```

## Template: Agent State File

**.claude/multi-agent-swarm.local.md:**

```markdown
---
agent_name: database-implementation
task_number: 4.2
pr_number: 5678
coordinator_session: team-leader
enabled: true
dependencies: ["Task 3.5", "Task 4.1"]
additional_instructions: "Use PostgreSQL, not MySQL"
---

# Task Assignment: Database Schema Implementation

Implement the database schema for the new features module.

## Requirements

- Create migration files
- Add indexes for performance
- Write tests for constraints
- Document schema in README

## Success Criteria

- Migrations run successfully
- All tests pass
- PR created with CI green
- Schema documented

## Coordination

Depends on:
- Task 3.5: API endpoint definitions
- Task 4.1: Data model design

Report status to coordinator session 'team-leader'.
```

## Template: Feature Flag Pattern

**.claude/experimental-features.local.md:**

```markdown
---
enabled: true
features:
  - ai_suggestions
  - auto_formatting
  - advanced_refactoring
experimental_mode: false
---

# Experimental Features Configuration

Current enabled features:
- AI-powered code suggestions
- Automatic code formatting
- Advanced refactoring tools

Experimental mode is OFF (stable features only).
```

## Usage in Hooks

These templates can be read by hooks:

```bash
# Check if plugin is configured
if [[ ! -f ".claude/my-plugin.local.md" ]]; then
  exit 0  # Not configured, skip hook
fi

# Read settings
FRONTMATTER=$(sed -n '/^---$/,/^---$/{ /^---$/d; p; }' ".claude/my-plugin.local.md")
ENABLED=$(echo "$FRONTMATTER" | grep '^enabled:' | sed 's/enabled: *//')

# Apply settings
if [[ "$ENABLED" == "true" ]]; then
  # Hook is active
  # ...
fi
```

## Gitignore

Always add to project `.gitignore`:

```gitignore
# Plugin settings (user-local, not committed)
.claude/*.local.md
.claude/*.local.json
```

## Editing Settings

Users can edit settings files manually:

```bash
# Edit settings
vim .claude/my-plugin.local.md

# Changes take effect after restart
exit  # Exit Claude Code
claude  # Restart
```

Changes require Claude Code restart - hooks can't be hot-swapped.


---
## financial-analysis-workflows-with-claude.md

- [](../15-Claude-AI-Features/claude-opus-4-6-anthropic.md)
    Opus
  - [](../15-Claude-AI-Features/claude-sonnet-4-6-anthropic.md)
    Sonnet
  - [](../15-Claude-AI-Features/claude-haiku-4-5-anthropic.md)
    Haiku

- Platform

  - [](/platform/api)
    Overview
  - [](https://platform.claude.com/docs)
    Developer docs
  - [](http://claude.com/pricing#api)
    Pricing

  - [](../04-API-Reference/Other/platform-claude-com.md)
    Console login

- Solutions

  Use cases

  - [](/solutions/agents)
    AI agents
  - [](/solutions/claude-code-security)
    Claude Code Security
  - [](/solutions/coding)
    Coding

  Industries

  - [](/solutions/customer-support)
    Customer support
  - [](/solutions/education)
    Education
  - [](/solutions/financial-services)
    Financial services
  - [](/solutions/government)
    Government
  - [](/solutions/healthcare)
    Healthcare
  - [](/solutions/life-sciences)
    Life sciences
  - [](/solutions/nonprofits)
    Nonprofits

- Pricing

  - [](/pricing)
    Overview
  - [](/pricing#api)
    API

  Pricing

  - [](/pricing/max)
    Max plan
  - [](/pricing/team)
    Team plan
  - [](/pricing/enterprise)
    Enterprise plan

- Resources

  Insights

  - [](/blog)
    Blog
  - [](/customers)
    Customer stories
  - [](https://www.anthropic.com/news)
    Anthropic news

  Learn

  - [](https://www.anthropic.com/learn)
    Anthropic Academy
  - [](/resources/courses)
    Courses
  - [](/resources/tutorials)
    Tutorials
  - [](/resources/use-cases)
    Use cases

  Tools

  - [](/connectors)
    Connectors
  - [](/plugins)
    Plugins

  Connect

  - [](https://www.anthropic.com/events)
    Events
  - [](/community)
    Community

- [](https://claude.ai/login)
  Login

&nbsp;

- 

  Contact sales

  [Contact sales](/contact-sales)
  Contact sales

- 

  Try Claude

  [Try Claude](https://claude.ai/)
  Try Claude

- 

  Contact sales

  [Contact sales](/contact-sales)
  Contact sales

- 

  Try Claude

  [Try Claude](https://claude.ai/)
  Try Claude

[](#)

- 

  Contact sales

  [Contact sales](/contact-sales)
  Contact sales

- 

  Try Claude

  [Try Claude](https://claude.ai/)
  Try Claude

- 

  Contact sales

  [Contact sales](/contact-sales)
  Contact sales

- 

  Try Claude

  [Try Claude](https://claude.ai/)
  Try Claude

- Meet Claude

  Products

  - [](/product/overview)
    Claude
  - [](/product/claude-code)
    Claude Code
  - [](/product/cowork)
    Claude Cowork

  Features

  - [](/claude-for-chrome)
    Claude for Chrome
  - [](/claude-for-slack)
    Claude for Slack
  - [](/claude-for-excel)
    Claude for Excel
  - [](/claude-for-powerpoint)
    Claude for PowerPoint
  - [](/skills)
    Skills

  Models

  - [](../15-Claude-AI-Features/claude-opus-4-6-anthropic.md)
    Opus
  - [](../15-Claude-AI-Features/claude-sonnet-4-6-anthropic.md)
    Sonnet
  - [](../15-Claude-AI-Features/claude-haiku-4-5-anthropic.md)
    Haiku

- Platform

  - [](/platform/api)
    Overview
  - [](https://platform.claude.com/docs)
    Developer docs
  - [](http://claude.com/pricing#api)
    Pricing

  - [](../04-API-Reference/Other/platform-claude-com.md)
    Console login

- Solutions

  Use cases

  - [](/solutions/agents)
    AI agents
  - [](/solutions/claude-code-security)
    Claude Code Security
  - [](/solutions/coding)
    Coding

  Industries

  - [](/solutions/customer-support)
    Customer support
  - [](/solutions/education)
    Education
  - [](/solutions/financial-services)
    Financial services
  - [](/solutions/government)
    Government
  - [](/solutions/healthcare)
    Healthcare
  - [](/solutions/life-sciences)
    Life sciences
  - [](/solutions/nonprofits)
    Nonprofits

- Pricing

  - [](/pricing)
    Overview
  - [](/pricing#api)
    API

  Pricing

  - [](/pricing/max)
    Max plan
  - [](/pricing/team)
    Team plan
  - [](/pricing/enterprise)
    Enterprise plan

- Resources

  Insights

  - [](/blog)
    Blog
  - [](/customers)
    Customer stories
  - [](https://www.anthropic.com/news)
    Anthropic news

  Learn

  - [](https://www.anthropic.com/learn)
    Anthropic Academy
  - [](/resources/courses)
    Courses
  - [](/resources/tutorials)
    Tutorials
  - [](/resources/use-cases)
    Use cases

  Tools

  - [](/connectors)
    Connectors
  - [](/plugins)
    Plugins

  Connect

  - [](https://www.anthropic.com/events)
    Events
  - [](/community)
    Community

- [](https://claude.ai/login)
  Login

- 

  Contact sales

  [Contact sales](/contact-sales)
  Contact sales

- 

  Try Claude

  [Try Claude](https://claude.ai/)
  Try Claude

- 

  Contact sales

  [Contact sales](/contact-sales)
  Contact sales

- 

  Try Claude

  [Try Claude](https://claude.ai/)
  Try Claude

1.  Tutorials

    [](/resources/tutorials)
    Tutorials

    /

2.  
    Financial analysis workflows with Claude

Explore here

- [](#)

  Ask questions about this page
- [](#)

  Copy as markdown

# Financial analysis workflows with Claude

Learn complete financial analysis workflows using a three-phase approach: retrieving data, analyzing information, and creating professional deliverables.

- 

  Category

  Finance

- 

  Product

  Claude.ai

- 

  Reading time

  Watch time

  5

  min

  min

- 

  Share

  [Copy link](#)
  https://claude.com/resources/tutorials/financial-analysis-workflows-with-claude

This article demonstrates how to use Claude for complete financial analysis workflows, from data retrieval through final deliverables. Each workflow follows a three-phase approach: retrieving data from integrated sources, analyzing the information to generate insights, and creating professional outputs for decision-making.

## Understanding the Workflow Approach

### The Three-Phase Process

Effective financial analysis with Claude follows a structured approach that mirrors traditional analytical workflows. The process begins with data retrieval from integrated sources, moves through systematic analysis of that data, and concludes with creation of professional deliverables. This structure ensures completeness while maintaining flexibility for different analytical objectives.

1.  **Retrieve:** Pull data from integrated sources including Daloopa for SEC filings and fundamentals, and S&P Global for comprehensive market data.. The retrieval phase establishes the factual foundation for your analysis.**‍**
2.  **Analyze:** Process and interpret the retrieved data to identify trends, calculate metrics, and generate insights. This phase transforms raw data into actionable intelligence through calculations, comparisons, and pattern recognition.**‍**
3.  **Create:** Generate professional deliverables including investment memos, presentations, financial models, and interactive dashboards. The creation phase packages your analysis into formats suitable for decision-making and communication.

### Setting Up Your Workspace

Before beginning your workflow, establish a proper workspace to maintain context and organization:

- Create a project for your analysis
- Upload any reference documents such as previous analyses or style guides

For detailed project setup instructions, see What are projects? The examples that follow assume you have the necessary integrations enabled and have created a project workspace.

## Workflow 1: Single Company Investment Memo

### Scenario Overview

This workflow demonstrates creating an investment memo for a potential equity investment using publicly available data. The example uses Microsoft as the target company, but the approach applies to any public company with sufficient data coverage. The final output is a concise investment memo suitable for investment committee review or initial screening documentation.

### Phase 1: Retrieve

Begin by gathering comprehensive financial data from multiple sources. Start with fundamental data:

Using Daloopa, retrieve Microsoft's revenue, operating margins, and free cash flow for the last 12 quarters. Also pull segment revenue breakdowns for the same period.

This retrieval provides the core financial metrics needed to assess operational performance and cash generation. The segment data reveals which business units drive growth and profitability. After retrieving fundamental data, gather valuation perspectives:

Using Kensho to access S&P Global data, identify Microsoft's main competitors from SEC filings and retrieve their revenue growth and operating margins for comparison. Also pull Microsoft's key business relationships including major customers and strategic partners.

Combining data from multiple sources provides both quantitative metrics and competitive context. Daloopa supplies the raw financial data while Kensho adds competitive positioning through peer comparisons and business relationship mapping.

### Phase 2: Analyze

With data retrieved, move to analysis that transforms raw numbers into insights:

Analyze the trends in Microsoft's cloud segment growth versus overall company growth. Calculate the free cash flow conversion rate and compare margins to the prior year. Also compare Microsoft's revenue growth and margins against the competitors we identified to assess relative performance. Identify any notable changes in segment mix and flag any customer concentration risks from the business relationships data.

Claude processes the retrieved data to identify patterns and calculate key ratios. The analysis reveals whether cloud services are becoming a larger portion of the business, how efficiently the company converts earnings to cash, and whether profitability is improving or declining.

Consider requesting additional analytical perspectives based on initial findings. If the cloud segment shows accelerating growth, you might ask Claude to analyze whether competitors are experiencing similar trends. If margins are expanding, request a comparison to peer margins to determine if this is company-specific or industry-wide.

### Phase 3: Create

Transform your analysis into a professional investment memo:

Create a 2-page investment memo for Microsoft including: executive summary with investment recommendation, business overview with segment analysis, financial performance highlighting the trends we identified, valuation using fair value compared to current price, and key risks. Format as a Word document.

The resulting memo synthesizes all previous analysis into a structured document.

This workflow produces a professional investment memo suitable for initial screening or committee review, created entirely from publicly available data through Claude's integrations.

## Workflow 2: Competitive Analysis Presentation

### Scenario Overview

This workflow creates a presentation comparing companies within a sector to identify the most attractive investment opportunity. The example analyzes SaaS companies, but the methodology applies to any sector where comparable metrics exist. The output is a presentation suitable for investment committee discussions or client meetings.

### Phase 1: Retrieve

Start by gathering comparable metrics across your peer group:

Using Kensho, retrieve market cap, P/E ratios, revenue growth, and EBITDA margins from S&P Global datasets for these 3 SaaS companies: CRM, NOW, and DOCU for the last fiscal year.

This establishes the baseline comparison metrics. Market cap provides size context, P/E ratios show relative valuation, revenue growth indicates momentum, and EBITDA margins reveal operational efficiency. After establishing the snapshot view, gather trend data:

Also get their quarterly revenue for the last 8 quarters to analyze growth consistency.

The quarterly data reveals whether growth is accelerating, decelerating, or remaining steady. This helps distinguish between companies with sustainable growth versus those experiencing temporary momentum.

### Phase 2: Analyze

Process the data to identify relative attractiveness:

Rank these companies by revenue growth and margin expansion. Calculate the PEG ratio for each. Identify which companies are gaining market share based on relative growth rates. Flag any companies with declining margins.

### Phase 3: Create

Transform the comparative analysis into a presentation:

Create a PowerPoint presentation with 6 slides: title slide, market overview with sector growth, comparative metrics table ranking all the companies, growth trajectory charts showing quarterly revenue trends, valuation comparison with P/E and PEG ratios, and investment recommendation slide highlighting the most attractive opportunity.

**Note:** PowerPoint creation currently has limitations with complex formatting and firm-specific templates. You may need to apply final formatting manually.

## Workflow 3: Portfolio Performance Review

### Scenario Overview

This workflow analyzes an existing portfolio to create performance reporting for quarterly reviews. The example uses a concentrated technology portfolio, but the approach scales to any holdings where data is available. The output is an interactive dashboard suitable for internal review or client reporting.

### Phase 1: Retrieve

Gather performance and fundamental data for all holdings:

Using FactSet, retrieve the following for my technology holdings (MSFT, AAPL): total returns for 1-month, 3-month, YTD and 1-year periods, current price and 52-week high/low, latest quarterly revenue and earnings with year-over-year growth rates, forward P/E ratios and consensus analyst ratings, and any recent earnings surprises. These holdings represent 60% of my portfolio with initial investments made in Q1 2024.

This provides data spanning performance metrics, valuation multiples, fundamental growth indicators, and forward-looking analyst sentiment.

### Phase 2: Analyze

Perform portfolio-level and position-level analysis:

Calculate the weighted average portfolio return based on position sizes for each time period. Compare each holding's total return against the NASDAQ-100 index returns. Rank holdings by YTD performance and identify any laggards. Calculate which positions have beaten or missed earnings expectations in the last quarter. Assess relative valuation by comparing each stock's forward P/E to its 5-year average.

This analysis provides multiple perspectives: weighted returns show overall portfolio performance across different time horizons, benchmark comparison reveals alpha generation, earnings surprise analysis indicates execution quality, and valuation assessment identifies potential rebalancing candidates.

### Phase 3: Create

Generate an interactive dashboard for the portfolio review:

Create an interactive artifact showing: portfolio summary with weighted returns for each period and performance versus benchmark, individual position cards showing total return, consensus rating, forward P/E, and recent earnings surprise, a waterfall chart showing each position's contribution to total portfolio return, and a scatter plot comparing YTD returns against forward P/E ratios to identify value opportunities. Include drill-down capability for each holding to see detailed performance metrics.

[Artifacts can be shared](../15-Claude-AI-Features/discovering-publishing-customizing-and-sharing-artifacts.md#h_264285dcf3) with other members of your organization. The interactive nature allows stakeholders to explore the data without requiring multiple static reports.

## Next Steps

- Review integration guides to understand data availability for your specific use cases.
- See [Prompting Strategies for Financial Analysis](../15-Claude-AI-Features/prompting-strategies-for-financial-analysis.md) for techniques to optimize your workflows.
- Test workflows with smaller datasets before scaling to full analyses.
- Save successful prompt sequences as templates for recurring analyses.

## Related tutorials

[How to build a plugin from scratch in Cowork](/resources/tutorials/how-to-build-a-plugin-from-scratch-in-cowork)

How to build a plugin from scratch in Cowork

How to build a plugin from scratch in Cowork

Tutorial

[Tutorial](/resources/tutorials/how-to-build-a-plugin-from-scratch-in-cowork)

Tutorial

[Getting started with Claude in Excel](/resources/tutorials/getting-started-with-claude-in-excel)

Getting started with Claude in Excel

Getting started with Claude in Excel

Tutorial

[Tutorial](/resources/tutorials/getting-started-with-claude-in-excel)

Tutorial

[How to use Claude in Excel for accounting: Revenue model validation](/resources/tutorials/how-to-use-claude-in-excel-for-accounting-revenue-model-validation)

How to use Claude in Excel for accounting: Revenue model validation

How to use Claude in Excel for accounting: Revenue model validation

Tutorial

[Tutorial](/resources/tutorials/how-to-use-claude-in-excel-for-accounting-revenue-model-validation)

Tutorial

[How to use Claude in Excel for HR: Headcount planning](/resources/tutorials/how-to-use-claude-in-excel-for-hr-headcount-planning)

How to use Claude in Excel for HR: Headcount planning

How to use Claude in Excel for HR: Headcount planning

Tutorial

[Tutorial](/resources/tutorials/how-to-use-claude-in-excel-for-hr-headcount-planning)

Tutorial

[Homepage](https://claude.com)

Homepage

[Next](#)

Next

Thank you! Your submission has been received!

Oops! Something went wrong while submitting the form.

Write

[Button Text](#)

Button Text

Learn

[Button Text](#)

Button Text

Code

[Button Text](#)

Button Text

Write

- Help me develop a unique voice for an audience

  [](#)

  Hi Claude! Could you help me develop a unique voice for an audience? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational.\
  \
  Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!

- Improve my writing style

  [](#)

  Hi Claude! Could you improve my writing style? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational.\
  \
  Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!

- Brainstorm creative ideas

  [](#)

  Hi Claude! Could you brainstorm creative ideas? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational.\
  \
  Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!

Learn

- Explain a complex topic simply

  [](#)

  Hi Claude! Could you explain a complex topic simply? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational.\
  \
  Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!

- Help me make sense of these ideas

  [](#)

  Hi Claude! Could you help me make sense of these ideas? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational.\
  \
  Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!

- Prepare for an exam or interview

  [](#)

  Hi Claude! Could you prepare for an exam or interview? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational.\
  \
  Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!

Code

- Explain a programming concept

  [](#)

  Hi Claude! Could you explain a programming concept? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational.\
  \
  Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!

- Look over my code and give me tips

  [](#)

  Hi Claude! Could you look over my code and give me tips? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational.\
  \
  Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!

- Vibe code with me

  [](#)

  Hi Claude! Could you vibe code with me? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational.\
  \
  Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!

More

- Write case studies

  [](#)

  This is another test

- Write grant proposals

  [](#)

  Hi Claude! Could you write grant proposals? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to — like Google Drive, web search, etc. — if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational.\
  \
  Please execute the task as soon as you can - an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!

- Write video scripts

  [](#)

  this is a test

[Anthropic](https://www.anthropic.com/)

Anthropic

© \[year\] Anthropic PBC

Products

- Claude

  [Claude](/product/overview)
  Claude

- Claude Code

  [Claude Code](/product/claude-code)
  Claude Code

- Claude Code for Enterprise

  [Claude Code for Enterprise](/product/claude-code/enterprise)
  Claude Code for Enterprise

- Claude Cowork

  [Claude Cowork](/product/cowork)
  Claude Cowork

- Max plan

  [Max plan](/pricing/max)
  Max plan

- Team plan

  [Team plan](/pricing/team)
  Team plan

- Enterprise plan

  [Enterprise plan](/pricing/enterprise)
  Enterprise plan

- Download app

  [Download app](/download)
  Download app

- Pricing

  [Pricing](/pricing)
  Pricing

- Log in

  [Log in](https://claude.ai/login)
  Log in

Features

- Claude for Chrome

  [Claude for Chrome](/claude-for-chrome)
  Claude for Chrome

- Claude for Slack

  [Claude for Slack](/claude-for-slack)
  Claude for Slack

- Claude for Excel

  [Claude for Excel](/claude-for-excel)
  Claude for Excel

- Claude for PowerPoint

  [Claude for PowerPoint](/claude-for-powerpoint)
  Claude for PowerPoint

- Skills

  [Skills](/skills)
  Skills

Models

- Opus

  [Opus](../15-Claude-AI-Features/claude-opus-4-6-anthropic.md)
  Opus

- Sonnet

  [Sonnet](../15-Claude-AI-Features/claude-sonnet-4-6-anthropic.md)
  Sonnet

- Haiku

  [Haiku](../15-Claude-AI-Features/claude-haiku-4-5-anthropic.md)
  Haiku

Solutions

- AI agents

  [AI agents](/solutions/agents)
  AI agents

- Claude Code Security

  [Claude Code Security](/solutions/claude-code-security)
  Claude Code Security

- Code modernization

  [Code modernization](/solutions/code-modernization)
  Code modernization

- Coding

  [Coding](/solutions/coding)
  Coding

- Customer support

  [Customer support](/solutions/customer-support)
  Customer support

- Education

  [Education](/solutions/education)
  Education

- Financial services

  [Financial services](/solutions/financial-services)
  Financial services

- Government

  [Government](/solutions/government)
  Government

- Healthcare

  [Healthcare](/solutions/healthcare)
  Healthcare

- Life sciences

  [Life sciences](/solutions/life-sciences)
  Life sciences

- Nonprofits

  [Nonprofits](/solutions/nonprofits)
  Nonprofits

Claude Platform

- Overview

  [Overview](/platform/api)
  Overview

- Developer docs

  [Developer docs](https://platform.claude.com/docs)
  Developer docs

- Pricing

  [Pricing](https://claude.com/pricing#api)
  Pricing

- Marketplace

  [Marketplace](/platform/marketplace)
  Marketplace

- Amazon Bedrock

  [Amazon Bedrock](/partners/amazon-bedrock)
  Amazon Bedrock

- Google Cloud’s Vertex AI

  [Google Cloud’s Vertex AI](/partners/google-cloud-vertex-ai)
  Google Cloud’s Vertex AI

- Microsoft Foundry

  [Microsoft Foundry](/partners/microsoft-foundry)
  Microsoft Foundry

- Regional compliance

  [Regional compliance](/regional-compliance)
  Regional compliance

- Console login

  [Console login](../04-API-Reference/Other/platform-claude-com.md)
  Console login

Resources

- Blog

  [Blog](/blog)
  Blog

- Claude partner network

  [Claude partner network](/partners)
  Claude partner network

- Community

  [Community](/community)
  Community

- Connectors

  [Connectors](/connectors)
  Connectors

- Courses

  [Courses](https://www.anthropic.com/learn)
  Courses

- Customer stories

  [Customer stories](/customers)
  Customer stories

- Engineering at Anthropic

  [Engineering at Anthropic](https://www.anthropic.com/engineering)
  Engineering at Anthropic

- Events

  [Events](https://www.anthropic.com/events)
  Events

- Plugins

  [Plugins](/plugins)
  Plugins

- Powered by Claude

  [Powered by Claude](/partners/powered-by-claude)
  Powered by Claude

- Service partners

  [Service partners](/partners/services)
  Service partners

- Startups program

  [Startups program](/programs/startups)
  Startups program

- Tutorials

  [Tutorials](/resources/tutorials)
  Tutorials

- Use cases

  [Use cases](/resources/use-cases)
  Use cases

Company

- Anthropic

  [Anthropic](https://www.anthropic.com/)
  Anthropic

- Careers

  [Careers](https://www.anthropic.com/careers)
  Careers

- Economic Futures

  [Economic Futures](https://www.anthropic.com/economic-futures)
  Economic Futures

- Research

  [Research](https://www.anthropic.com/research)
  Research

- News

  [News](https://www.anthropic.com/news)
  News

- Responsible Scaling Policy

  [Responsible Scaling Policy](../19-Reference/announcing-our-updated-responsible-scaling-policy-anthropic.md)
  Responsible Scaling Policy

- Security and compliance

  [Security and compliance](https://trust.anthropic.com/)
  Security and compliance

- Transparency

  [Transparency](https://anthropic.com/transparency)
  Transparency

Help and security

- Availability

  [Availability](https://www.anthropic.com/supported-countries)
  Availability

- Status

  [Status](https://status.anthropic.com/)
  Status

- Support center

  [Support center](https://support.claude.com/en/)
  Support center

Terms and policies

Privacy choices

### Cookie settings

We use cookies to deliver and improve our services, analyze site usage, and if you agree, to customize or personalize your experience and market our services to you. You can read our Cookie Policy [here](https://www.anthropic.com/legal/cookies).

Customize cookie settings

Reject all cookies

Accept all cookies

###### Necessary

Enables security and basic functionality.

Required

###### Analytics

Enables tracking of site performance.

Off

###### Marketing

Enables ads personalization and tracking.

Off

Save preferences

Privacy policy

[Privacy policy](https://www.anthropic.com/legal/privacy)

Privacy policy

Responsible disclosure policy

[Responsible disclosure policy](https://www.anthropic.com/responsible-disclosure-policy)

Responsible disclosure policy

Terms of service: Commercial

[Terms of service: Commercial](https://www.anthropic.com/legal/commercial-terms)

Terms of service: Commercial

Terms of service: Consumer

[Terms of service: Consumer](https://www.anthropic.com/legal/consumer-terms)

Terms of service: Consumer

Usage policy

[Usage policy](https://www.anthropic.com/legal/aup)

Usage policy

[x.com](https://x.com/claudeai)

x.com

[LinkedIn](https://www.linkedin.com/showcase/claude/)

LinkedIn

[YouTube](https://www.youtube.com/@anthropic-ai)

YouTube

[Instagram](https://www.instagram.com/claudeai)

Instagram

English (US)

[English (US)](/resources/tutorials/financial-analysis-workflows-with-claude)

[日本語 (Japan)](/ja-jp)

[Deutsch (Germany)](/de-de)

[Français (France)](/fr-fr)

[한국어 (South Korea)](/ko-kr)


---
## get-started-8965568146.md

# Get started with Claude

Make your first API call to Claude and build a simple web search assistant.

---

## Prerequisites

- An Anthropic [Console account](/)
- An [API key](/settings/keys)

## Call the API

<Tabs>
  <Tab title="cURL">
    <Steps>
      <Step title="Set your API key">
        Get your API key from the [Claude Console](/settings/keys) and set it as an environment variable:

        ```bash
        export ANTHROPIC_API_KEY='your-api-key-here'
        ```

        To persist the key across shell sessions, add the line to your shell profile (such as `~/.zshrc` or `~/.bashrc`).
      </Step>

      <Step title="Make your first API call">
        Run this command to create a simple web search assistant:

        ```bash cURL
        curl https://api.anthropic.com/v1/messages \
          -H "Content-Type: application/json" \
          -H "x-api-key: $ANTHROPIC_API_KEY" \
          -H "anthropic-version: 2023-06-01" \
          -d '{
            "model": "claude-opus-4-7",
            "max_tokens": 1000,
            "messages": [
              {
                "role": "user",
                "content": "What should I search for to find the latest developments in renewable energy?"
              }
            ]
          }'
        ```

        **Example output:**
        ```json Output
        {
          "id": "msg_01HCDu5LRGeP2o7s2xGmxyx8",
          "type": "message",
          "role": "assistant",
          "content": [
            {
              "type": "text",
              "text": "Here are some effective search strategies to find the latest renewable energy developments:\n\n## Search Terms to Use:\n- \"renewable energy news 2024\"\n- \"clean energy breakthrough\"\n- \"solar/wind/battery technology advances\"\n- \"green energy innovations\"\n- \"climate tech developments\"\n- \"energy storage solutions\"\n\n## Best Sources to Check:\n\n**News & Industry Sites:**\n- Renewable Energy World\n- GreenTech Media (now Wood Mackenzie)\n- Energy Storage News\n- CleanTechnica\n- PV Magazine (for solar)\n- WindPower Engineering & Development..."
            }
          ],
          "model": "claude-opus-4-7",
          "stop_reason": "end_turn",
          "usage": {
            "input_tokens": 21,
            "output_tokens": 305
          }
        }
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="CLI">
    <Steps>
      <Step title="Set your API key">
        Get your API key from the [Claude Console](/settings/keys) and set it as an environment variable:

        ```bash
        export ANTHROPIC_API_KEY='your-api-key-here'
        ```

        To persist the key across shell sessions, add the line to your shell profile (such as `~/.zshrc` or `~/.bashrc`).
      </Step>

      <Step title="Install the CLI">
        Install the Anthropic CLI with Homebrew:

        ```bash
        brew install anthropics/tap/ant
        ```

        For other installation methods, see [Installation](/docs/en/api/sdks/cli#installation) in the CLI reference.
      </Step>

      <Step title="Make your first API call">
        Run this command to create a simple web search assistant:

        ```bash
        ant messages create \
          --model claude-opus-4-7 \
          --max-tokens 1000 \
          --message '{
            role: user,
            content: "What should I search for to find the latest developments in renewable energy?"
          }'
        ```

        **Example output:**
        ```json Output
        {
          "id": "msg_01HCDu5LRGeP2o7s2xGmxyx8",
          "type": "message",
          "role": "assistant",
          "content": [
            {
              "type": "text",
              "text": "Here are some effective search strategies to find the latest renewable energy developments:\n\n## Search Terms to Use:\n- \"renewable energy news 2024\"\n- \"clean energy breakthrough\"\n- \"solar/wind/battery technology advances\"\n- \"green energy innovations\"\n- \"climate tech developments\"\n- \"energy storage solutions\"\n\n## Best Sources to Check:\n\n**News & Industry Sites:**\n- Renewable Energy World\n- GreenTech Media (now Wood Mackenzie)\n- Energy Storage News\n- CleanTechnica\n- PV Magazine (for solar)\n- WindPower Engineering & Development..."
            }
          ],
          "model": "claude-opus-4-7",
          "stop_reason": "end_turn",
          "usage": {
            "input_tokens": 21,
            "output_tokens": 305
          }
        }
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="Python">
    <Steps>
      <Step title="Set your API key">
        Get your API key from the [Claude Console](/settings/keys) and set it as an environment variable:

        ```bash
        export ANTHROPIC_API_KEY='your-api-key-here'
        ```

        To persist the key across shell sessions, add the line to your shell profile (such as `~/.zshrc` or `~/.bashrc`).
      </Step>

      <Step title="Install the SDK">
        Install the Anthropic Python SDK:

        ```bash
        pip install anthropic
        ```
      </Step>

      <Step title="Create your code">
        Save this as `quickstart.py`:

        ```python
        import anthropic

        client = anthropic.Anthropic()

        message = client.messages.create(
            model="claude-opus-4-7",
            max_tokens=1000,
            messages=[
                {
                    "role": "user",
                    "content": "What should I search for to find the latest developments in renewable energy?",
                }
            ],
        )
        print(message.content)
        ```
      </Step>

      <Step title="Run your code">
        ```bash
        python quickstart.py
        ```

        **Example output:**
        ```text Output
        [
            TextBlock(
                text='Here are some effective search strategies for finding the latest renewable energy developments:\n\n**Search Terms to Use:**\n- "renewable energy news 2024"\n- "clean energy breakthroughs"\n- "solar/wind/battery technology advances"\n- "energy storage innovations"\n- "green hydrogen developments"\n- "renewable energy policy updates"\n\n**Reliable Sources to Check:**\n- **News & Analysis:** Reuters Energy, Bloomberg New Energy Finance, Greentech Media, Energy Storage News\n- **Industry Publications:** Renewable Energy World, PV Magazine, Wind Power Engineering\n- **Research Organizations:** International Energy Agency (IEA), National Renewable Energy Laboratory (NREL)\n- **Government Sources:** Department of Energy websites, EPA clean energy updates\n\n**Specific Topics to Explore:**\n- Perovskite and next-gen solar cells\n- Offshore wind expansion\n- Grid-scale battery storage\n- Green hydrogen production\n- Carbon capture technologies\n- Smart grid innovations\n- Energy policy changes and incentives...',
                type="text",
            )
        ]
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="TypeScript">
    <Steps>
      <Step title="Set your API key">
        Get your API key from the [Claude Console](/settings/keys) and set it as an environment variable:

        ```bash
        export ANTHROPIC_API_KEY='your-api-key-here'
        ```

        To persist the key across shell sessions, add the line to your shell profile (such as `~/.zshrc` or `~/.bashrc`).
      </Step>

      <Step title="Install the SDK">
        Install the Anthropic TypeScript SDK:

        ```bash
        npm install @anthropic-ai/sdk
        ```
      </Step>

      <Step title="Create your code">
        Save this as `quickstart.ts`:

```typescript
import Anthropic from "@anthropic-ai/sdk";

async function main() {
  const anthropic = new Anthropic();

  const msg = await anthropic.messages.create({
    model: "claude-opus-4-7",
    max_tokens: 1000,
    messages: [
      {
        role: "user",
        content:
          "What should I search for to find the latest developments in renewable energy?"
      }
    ]
  });
  console.log(msg);
}

main().catch(console.error);
        ```
      </Step>

      <Step title="Run your code">
        ```bash
        npx tsx quickstart.ts
        ```

        **Example output:**
        ```javascript Output hidelines={1..2}
        const _ =
          // output
          {
            id: "msg_01ThFHzad6Bh4TpQ6cHux9t8",
            type: "message",
            role: "assistant",
            model: "claude-opus-4-7",
            content: [
              {
                type: "text",
                text:
                  "Here are some effective search strategies to find the latest renewable energy developments:\n\n" +
                  "## Search Terms to Use:\n" +
                  '- "renewable energy news 2024"\n' +
                  '- "clean energy breakthroughs"\n' +
                  '- "solar wind technology advances"\n' +
                  '- "energy storage innovations"\n' +
                  '- "green hydrogen developments"\n' +
                  '- "offshore wind projects"\n' +
                  '- "battery technology renewable"\n\n' +
                  "## Best Sources to Check:\n\n" +
                  "**News & Industry Sites:**\n" +
                  "- Renewable Energy World\n" +
                  "- CleanTechnica\n" +
                  "- GreenTech Media (now Wood Mackenzie)\n" +
                  "- Energy Storage News\n" +
                  "- PV Magazine (for solar)..."
              }
            ],
            stop_reason: "end_turn",
            usage: {
              input_tokens: 21,
              output_tokens: 302
            }
          }
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="Java">
    <Steps>
      <Step title="Set your API key">
        Get your API key from the [Claude Console](/settings/keys) and set it as an environment variable:

        ```bash
        export ANTHROPIC_API_KEY='your-api-key-here'
        ```

        To persist the key across shell sessions, add the line to your shell profile (such as `~/.zshrc` or `~/.bashrc`).
      </Step>

      <Step title="Install the SDK">
        Add the Anthropic Java SDK to your project. First find the current version on [Maven Central](https://central.sonatype.com/artifact/com.anthropic/anthropic-java).

        **Gradle:**
        ```groovy
        implementation("com.anthropic:anthropic-java:2.27.0")
        ```

        **Maven:**
        ```xml
        <dependency>
          <groupId>com.anthropic</groupId>
          <artifactId>anthropic-java</artifactId>
          <version>2.27.0</version>
        </dependency>
        ```
      </Step>

      <Step title="Create your code">
        Save this as `QuickStart.java`:

        ```java
        import com.anthropic.client.AnthropicClient;
        import com.anthropic.client.okhttp.AnthropicOkHttpClient;
        import com.anthropic.models.messages.Message;
        import com.anthropic.models.messages.MessageCreateParams;

        public class QuickStart {

          public static void main(String[] args) {
            AnthropicClient client = AnthropicOkHttpClient.fromEnv();

            MessageCreateParams params = MessageCreateParams.builder()
              .model("claude-opus-4-7")
              .maxTokens(1000)
              .addUserMessage(
                "What should I search for to find the latest developments in renewable energy?"
              )
              .build();

            Message message = client.messages().create(params);
            System.out.println(message.content());
          }
        }
        ```
      </Step>

      <Step title="Run your code">
        ```bash
        javac QuickStart.java
        java QuickStart
        ```

        **Example output:**
        ```text Output
        [ContentBlock{text=TextBlock{text=Here are some effective search strategies to find the latest renewable energy developments:

        ## Search Terms to Use:
        - "renewable energy news 2024"
        - "clean energy breakthroughs"
        - "solar/wind/battery technology advances"
        - "energy storage innovations"
        - "green hydrogen developments"
        - "renewable energy policy updates"

        ## Best Sources to Check:
        - **News & Analysis:** Reuters Energy, Bloomberg New Energy Finance, Greentech Media
        - **Industry Publications:** Renewable Energy World, PV Magazine, Wind Power Engineering
        - **Research Organizations:** International Energy Agency (IEA), National Renewable Energy Laboratory (NREL)
        - **Government Sources:** Department of Energy websites, EPA clean energy updates

        ## Specific Topics to Explore:
        - Perovskite and next-gen solar cells
        - Offshore wind expansion
        - Grid-scale battery storage
        - Green hydrogen production..., type=text}}]
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

## Next steps

You made your first API call. Next, learn the Messages API patterns you'll use in every Claude integration.

<Card title="Working with the Messages API" icon="messages" href="/docs/en/build-with-claude/working-with-messages">
  Learn multi-turn conversations, system prompts, stop reasons, and other core patterns.
</Card>

Once you're comfortable with the basics, explore further:

<CardGroup cols={3}>
  <Card title="Models overview" icon="brain" href="/docs/en/about-claude/models/overview">
    Compare Claude models by capability and cost.
  </Card>
  <Card title="Features overview" icon="list" href="/docs/en/build-with-claude/overview">
    Browse all Claude capabilities: tools, context management, structured outputs, and more.
  </Card>
  <Card title="Client SDKs" icon="code-brackets" href="/docs/en/api/client-sdks">
    Reference documentation for Python, TypeScript, Java, and other client libraries.
  </Card>
</CardGroup>

---
## get-started.md

# Get started with Claude


Make your first API call to Claude and build a simple web search assistant.


Prerequisites

- An Anthropic [Console account](/)
- An [API key](/settings/keys)


Call the API

cURL

cURL

Python

Python

TypeScript

TypeScript

Java

Java

1.  1

    Set your API key

    Get your API key from the [Claude Console](/settings/keys) and set it as an environment variable:

    ``` shiki
    export ANTHROPIC_API_KEY='your-api-key-here'
    ```

2.  2

    Make your first API call

    Run this command to create a simple web search assistant:

    ``` shiki
    curl https://api.anthropic.com/v1/messages \
      -H "Content-Type: application/json" \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2023-06-01" \
      -d '{
        "model": "claude-opus-4-6",
        "max_tokens": 1000,
        "messages": [
          {
            "role": "user",
            "content": "What should I search for to find the latest developments in renewable energy?"
          }
        ]
      }'
    ```

    **Example output:**

    ``` shiki
    {
      "id": "msg_01HCDu5LRGeP2o7s2xGmxyx8",
      "type": "message",
      "role": "assistant",
      "content": [
        {
          "type": "text",
          "text": "Here are some effective search strategies to find the latest renewable energy developments:\n\n## Search Terms to Use:\n- \"renewable energy news 2024\"\n- \"clean energy breakthrough\"\n- \"solar/wind/battery technology advances\"\n- \"green energy innovations\"\n- \"climate tech developments\"\n- \"energy storage solutions\"\n\n## Best Sources to Check:\n\n**News & Industry Sites:**\n- Renewable Energy World\n- GreenTech Media (now Wood Mackenzie)\n- Energy Storage News\n- CleanTechnica\n- PV Magazine (for solar)\n- WindPower Engineering & Development..."
        }
      ],
      "model": "claude-opus-4-6",
      "stop_reason": "end_turn",
      "usage": {
        "input_tokens": 21,
        "output_tokens": 305
      }
    }
    ```


Next steps

You made your first API call. Next, learn the Messages API patterns you'll use in every Claude integration.


Working with the Messages API

Learn multi-turn conversations, system prompts, stop reasons, and other core patterns.

Once you're comfortable with the basics, explore further:


Models overview

Compare Claude models by capability and cost.


Features overview

Browse all Claude capabilities: tools, context management, structured outputs, and more.


Client SDKs

Reference documentation for Python, TypeScript, Java, and other client libraries.


---
## getting-started-with-claude-for-life-sciences.md

- [](../15-Claude-AI-Features/claude-opus-4-6-anthropic.md)
    Opus
  - [](../15-Claude-AI-Features/claude-sonnet-4-6-anthropic.md)
    Sonnet
  - [](../15-Claude-AI-Features/claude-haiku-4-5-anthropic.md)
    Haiku

- Platform

  - [](/platform/api)
    Overview
  - [](https://platform.claude.com/docs)
    Developer docs
  - [](http://claude.com/pricing#api)
    Pricing

  - [](../04-API-Reference/Other/platform-claude-com.md)
    Console login

- Solutions

  Use cases

  - [](/solutions/agents)
    AI agents
  - [](/solutions/claude-code-security)
    Claude Code Security
  - [](/solutions/coding)
    Coding

  Industries

  - [](/solutions/customer-support)
    Customer support
  - [](/solutions/education)
    Education
  - [](/solutions/financial-services)
    Financial services
  - [](/solutions/government)
    Government
  - [](/solutions/healthcare)
    Healthcare
  - [](/solutions/life-sciences)
    Life sciences
  - [](/solutions/nonprofits)
    Nonprofits

- Pricing

  - [](/pricing)
    Overview
  - [](/pricing#api)
    API

  Pricing

  - [](/pricing/max)
    Max plan
  - [](/pricing/team)
    Team plan
  - [](/pricing/enterprise)
    Enterprise plan

- Resources

  Insights

  - [](/blog)
    Blog
  - [](/customers)
    Customer stories
  - [](https://www.anthropic.com/news)
    Anthropic news

  Learn

  - [](https://www.anthropic.com/learn)
    Anthropic Academy
  - [](/resources/courses)
    Courses
  - [](/resources/tutorials)
    Tutorials
  - [](/resources/use-cases)
    Use cases

  Tools

  - [](/connectors)
    Connectors
  - [](/plugins)
    Plugins

  Connect

  - [](https://www.anthropic.com/events)
    Events
  - [](/community)
    Community

- [](https://claude.ai/login)
  Login

&nbsp;

- 

  Contact sales

  [Contact sales](/contact-sales)
  Contact sales

- 

  Try Claude

  [Try Claude](https://claude.ai/)
  Try Claude

- 

  Contact sales

  [Contact sales](/contact-sales)
  Contact sales

- 

  Try Claude

  [Try Claude](https://claude.ai/)
  Try Claude

[](#)

- 

  Contact sales

  [Contact sales](/contact-sales)
  Contact sales

- 

  Try Claude

  [Try Claude](https://claude.ai/)
  Try Claude

- 

  Contact sales

  [Contact sales](/contact-sales)
  Contact sales

- 

  Try Claude

  [Try Claude](https://claude.ai/)
  Try Claude

- Meet Claude

  Products

  - [](/product/overview)
    Claude
  - [](/product/claude-code)
    Claude Code
  - [](/product/cowork)
    Claude Cowork

  Features

  - [](/claude-for-chrome)
    Claude for Chrome
  - [](/claude-for-slack)
    Claude for Slack
  - [](/claude-for-excel)
    Claude for Excel
  - [](/claude-for-powerpoint)
    Claude for PowerPoint
  - [](/skills)
    Skills

  Models

  - [](../15-Claude-AI-Features/claude-opus-4-6-anthropic.md)
    Opus
  - [](../15-Claude-AI-Features/claude-sonnet-4-6-anthropic.md)
    Sonnet
  - [](../15-Claude-AI-Features/claude-haiku-4-5-anthropic.md)
    Haiku

- Platform

  - [](/platform/api)
    Overview
  - [](https://platform.claude.com/docs)
    Developer docs
  - [](http://claude.com/pricing#api)
    Pricing

  - [](../04-API-Reference/Other/platform-claude-com.md)
    Console login

- Solutions

  Use cases

  - [](/solutions/agents)
    AI agents
  - [](/solutions/claude-code-security)
    Claude Code Security
  - [](/solutions/coding)
    Coding

  Industries

  - [](/solutions/customer-support)
    Customer support
  - [](/solutions/education)
    Education
  - [](/solutions/financial-services)
    Financial services
  - [](/solutions/government)
    Government
  - [](/solutions/healthcare)
    Healthcare
  - [](/solutions/life-sciences)
    Life sciences
  - [](/solutions/nonprofits)
    Nonprofits

- Pricing

  - [](/pricing)
    Overview
  - [](/pricing#api)
    API

  Pricing

  - [](/pricing/max)
    Max plan
  - [](/pricing/team)
    Team plan
  - [](/pricing/enterprise)
    Enterprise plan

- Resources

  Insights

  - [](/blog)
    Blog
  - [](/customers)
    Customer stories
  - [](https://www.anthropic.com/news)
    Anthropic news

  Learn

  - [](https://www.anthropic.com/learn)
    Anthropic Academy
  - [](/resources/courses)
    Courses
  - [](/resources/tutorials)
    Tutorials
  - [](/resources/use-cases)
    Use cases

  Tools

  - [](/connectors)
    Connectors
  - [](/plugins)
    Plugins

  Connect

  - [](https://www.anthropic.com/events)
    Events
  - [](/community)
    Community

- [](https://claude.ai/login)
  Login

- 

  Contact sales

  [Contact sales](/contact-sales)
  Contact sales

- 

  Try Claude

  [Try Claude](https://claude.ai/)
  Try Claude

- 

  Contact sales

  [Contact sales](/contact-sales)
  Contact sales

- 

  Try Claude

  [Try Claude](https://claude.ai/)
  Try Claude

1.  Tutorials

    [](/resources/tutorials)
    Tutorials

    /

2.  
    Getting Started with Claude for Life Sciences

Explore here

- [](#)

  Ask questions about this page
- [](#)

  Copy as markdown

# Getting Started with Claude for Life Sciences

- 

  Category

  Life Sciences

- 

  Product

  Claude.ai

- 

  Reading time

  Watch time

  5

  min

  min

- 

  Share

  [Copy link](#)
  https://claude.com/resources/tutorials/getting-started-with-claude-for-life-sciences

## What is Claude for Life Sciences

Claude for Life Sciences enhances Claude with specialized capabilities for life sciences researchers and organizations. It connects Claude to the data sources, tools, and systems that teams use daily across R&D, clinical operations, and regulatory affairs — eliminating the need to toggle between platforms and enabling insights that span your entire product lifecycle. The result: accelerated timelines from discovery through approval, with the rigor and traceability these workflows demand.

## How do I access life sciences tools and features?

Individuals can access Claude for Life Sciences features and tools from a [Claude Pro](https://claude.com/pricing) or [Claude Max](https://claude.com/pricing) account, and teams can access through [Claude for Work](https://www.claude.com/pricing/team). For questions about Claude for Life Sciences for enterprise contact our [Sales team](https://claude.com/contact-sales/life-sciences).

## **Connectors for the life sciences development cycle**

Through Model Context Protocol (MCP) [connectors](../15-Claude-AI-Features/browsing-and-connecting-to-tools-from-the-directory.md) and [desktop extensions](https://support.claude.com/en/articles/10949351-getting-started-with-local-mcp-servers-on-claude-desktop), Claude connects directly to leading platforms and databases, enabling you to query data using natural language and receive responses with source citations.

**Scientific research & discovery**

- [**Benchling**](https://claude.com/resources/tutorials/using-the-benchling-connector-in-claude) connects Claude to Benchling R&D platform data, enabling scientists to ask questions and receive clear summaries with links back to source experiments, notebooks, and structured records—all while maintaining existing access permissions.
- [**10x Genomics**](https://claude.com/resources/tutorials/using-the-10x-genomics-extension-in-claude)**\*** transforms single cell and spatial analysis into a simple, conversational workflow. Biologists can easily analyze their own sequencing data, while core labs can quickly perform batch processing.
- [**PubMed**](https://claude.com/resources/tutorials/using-the-pubmed-connector-in-claude) provides access to millions of biomedical research articles and clinical studies, allowing Claude to access abstracts and full papers to clarify experimental approaches, identify key findings, determine novelty and applicability, and surface specific papers for deeper exploration
- [**Synapse.org**](https://claude.com/resources/tutorials/using-the-synapse-org-connector-in-claude) allows researchers to discover biomedical data across all of Synapse, see the structure of projects, and retrieve information on their data assets for authorized users.
- [**BioRender**](https://claude.com/resources/tutorials/using-the-biorender-connector-in-claude) searches BioRender's extensive scientific figure template and icon collection for relevant content to create figures faster.
- [**Scholar Gateway by Wiley**](https://claude.com/resources/tutorials/using-the-scholar-gateway-connector-in-claude) provides authenticated access to the most relevant snippets of scientific research papers to utilize within Claude.
- [**bioRxiv / medRxiv**](https://claude.com/resources/tutorials/using-the-biorxiv-and-medrxiv-connector-in-claude) gives Claude access to bioRxiv and medRxiv preprint servers, enabling researchers to search, retrieve, and analyze non-peer-reviewed scientific manuscripts in biological and health sciences before formal journal publication.**‍**
- [**ChEMBL**](https://claude.com/resources/tutorials/using-the-chembl-connector-in-claude) gives Claude access to a manually curated repository of bioactive molecules with drug-like properties, their biological targets, and quantitative activity measurements.**‍**
- [**ToolUniverse**](https://claude.com/resources/tutorials/using-the-tooluniverse-extension-in-claude)**\*** gives Claude access to a library of 600+ vetted scientific tools to explore large hypothesis spaces, compare competing hypotheses, and iterate through fast-to-slow cycles of analysis.**‍**
- [**Owkin**](https://claude.com/resources/tutorials/using-the-owkin-connector-in-claude) powers Pathology Explorer, an Owkin AI agent that transforms H&E pathology slides into queryable insights for drug discovery and development and clinical research.
- [**Open Targets**](https://claude.com/resources/tutorials/using-the-open-targets-connector-in-claude) gives Claude access to the Open Targets Platform for identifying and prioritizing therapeutic drug targets based on disease associations.

***‍*Clinical operations & regulatory**

- [**Medidata**](https://claude.com/resources/tutorials/using-the-medidata-connector-in-claude), a leader in clinical trial solutions, provides the ability to connect Claude to their Medidata platform data
- [**ClinicalTrials.gov**](https://claude.com/resources/tutorials/using-the-clinicaltrials-gov-connector-in-claude) gives Claude access to the NIH/NLM registry of 500,000+ clinical studies to search trials, analyze endpoints, and support research operations.

*\*Available as Desktop Extensions for access on Claude Desktop App (*[*download here*](https://claude.ai/download)*).*

Claude also includes Connectors to other workplace and productivity platforms like **Microsoft 365**, **Gmail & Google Drive**, **Box**, **Databricks**, **Slack**, and many more. Explore all available Claude Connectors [here](../04-API-Reference/Other/connectors-claude.md).

You can also add custom connectors to connect Claude directly to the tools and data sources that matter most to your workflows. Learn more about setting up custom connectors [here](../14-Connectors/getting-started-with-custom-connectors-using-remote-mcp.md).

## Common research & discovery use cases

- **Advanced data analysis and hypothesis generation:** Synthesize multi-source data to accelerate discovery cycles from weeks to hours.**‍**
- **Literature synthesis with citations:** Access abstracts and full papers to clarify experimental approaches, identify key findings, determine novelty and applicability, and surface specific papers for deeper exploration.**‍**
- **Protocol optimization:** Generate optimized protocols by synthesizing literature, successful existing protocols, and experimental best practices.**‍**
- **Single-cell data processing:** Synthesize days of bioinformatics and computational analysis in minutes with automated cell population identification. Check out the [single-cell-rna-qc skill](../02-Claude-Code-CLI/how-to-use-the-single-cell-rna-qc-skill-with-claude.md) which gives Claude the ability to perform quality control on single-cell RNA-seq data using scverse best practices.**‍**
- **Experimental design automation:** Generate literature-informed experimental designs automatically.**‍**
- **Figure interpretation and analysis:** Accelerate figure creation and analysis with automated visualization.

## Related tutorials

[How to use the Nextflow Deployment agent skill with Claude Code](/resources/tutorials/how-to-use-the-nextflow-deployment-agent-skill-with-claude-code)

How to use the Nextflow Deployment agent skill with Claude Code

How to use the Nextflow Deployment agent skill with Claude Code

Tutorial

[Tutorial](/resources/tutorials/how-to-use-the-nextflow-deployment-agent-skill-with-claude-code)

Tutorial

[How to use the Instrument Data to Allotrope Skill with Claude](/resources/tutorials/how-to-use-the-instrument-data-to-allotrope-skill-with-claude)

How to use the Instrument Data to Allotrope Skill with Claude

How to use the Instrument Data to Allotrope Skill with Claude

Tutorial

[Tutorial](/resources/tutorials/how-to-use-the-instrument-data-to-allotrope-skill-with-claude)

Tutorial

[How to use the Scientific Problem Selection Skill with Claude](/resources/tutorials/how-to-use-the-scientific-problem-selection-skill-with-claude)

How to use the Scientific Problem Selection Skill with Claude

How to use the Scientific Problem Selection Skill with Claude

Tutorial

[Tutorial](/resources/tutorials/how-to-use-the-scientific-problem-selection-skill-with-claude)

Tutorial

[How to use the scVI-Tools bioinformatics skill bundle with Claude](/resources/tutorials/how-to-use-the-scvi-tools-bioinformatics-skill-bundle-with-claude)

How to use the scVI-Tools bioinformatics skill bundle with Claude

How to use the scVI-Tools bioinformatics skill bundle with Claude

Tutorial

[Tutorial](/resources/tutorials/how-to-use-the-scvi-tools-bioinformatics-skill-bundle-with-claude)

Tutorial

[Homepage](https://claude.com)

Homepage

[Next](#)

Next

Thank you! Your submission has been received!

Oops! Something went wrong while submitting the form.

Write

[Button Text](#)

Button Text

Learn

[Button Text](#)

Button Text

Code

[Button Text](#)

Button Text

Write

- Help me develop a unique voice for an audience

  [](#)

  Hi Claude! Could you help me develop a unique voice for an audience? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational.\
  \
  Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!

- Improve my writing style

  [](#)

  Hi Claude! Could you improve my writing style? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational.\
  \
  Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!

- Brainstorm creative ideas

  [](#)

  Hi Claude! Could you brainstorm creative ideas? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational.\
  \
  Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!

Learn

- Explain a complex topic simply

  [](#)

  Hi Claude! Could you explain a complex topic simply? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational.\
  \
  Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!

- Help me make sense of these ideas

  [](#)

  Hi Claude! Could you help me make sense of these ideas? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational.\
  \
  Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!

- Prepare for an exam or interview

  [](#)

  Hi Claude! Could you prepare for an exam or interview? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational.\
  \
  Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!

Code

- Explain a programming concept

  [](#)

  Hi Claude! Could you explain a programming concept? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational.\
  \
  Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!

- Look over my code and give me tips

  [](#)

  Hi Claude! Could you look over my code and give me tips? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational.\
  \
  Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!

- Vibe code with me

  [](#)

  Hi Claude! Could you vibe code with me? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational.\
  \
  Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!

More

- Write case studies

  [](#)

  This is another test

- Write grant proposals

  [](#)

  Hi Claude! Could you write grant proposals? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to — like Google Drive, web search, etc. — if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational.\
  \
  Please execute the task as soon as you can - an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!

- Write video scripts

  [](#)

  this is a test

[Anthropic](https://www.anthropic.com/)

Anthropic

© \[year\] Anthropic PBC

Products

- Claude

  [Claude](/product/overview)
  Claude

- Claude Code

  [Claude Code](/product/claude-code)
  Claude Code

- Claude Code for Enterprise

  [Claude Code for Enterprise](/product/claude-code/enterprise)
  Claude Code for Enterprise

- Claude Cowork

  [Claude Cowork](/product/cowork)
  Claude Cowork

- Max plan

  [Max plan](/pricing/max)
  Max plan

- Team plan

  [Team plan](/pricing/team)
  Team plan

- Enterprise plan

  [Enterprise plan](/pricing/enterprise)
  Enterprise plan

- Download app

  [Download app](/download)
  Download app

- Pricing

  [Pricing](/pricing)
  Pricing

- Log in

  [Log in](https://claude.ai/login)
  Log in

Features

- Claude for Chrome

  [Claude for Chrome](/claude-for-chrome)
  Claude for Chrome

- Claude for Slack

  [Claude for Slack](/claude-for-slack)
  Claude for Slack

- Claude for Excel

  [Claude for Excel](/claude-for-excel)
  Claude for Excel

- Claude for PowerPoint

  [Claude for PowerPoint](/claude-for-powerpoint)
  Claude for PowerPoint

- Skills

  [Skills](/skills)
  Skills

Models

- Opus

  [Opus](../15-Claude-AI-Features/claude-opus-4-6-anthropic.md)
  Opus

- Sonnet

  [Sonnet](../15-Claude-AI-Features/claude-sonnet-4-6-anthropic.md)
  Sonnet

- Haiku

  [Haiku](../15-Claude-AI-Features/claude-haiku-4-5-anthropic.md)
  Haiku

Solutions

- AI agents

  [AI agents](/solutions/agents)
  AI agents

- Claude Code Security

  [Claude Code Security](/solutions/claude-code-security)
  Claude Code Security

- Code modernization

  [Code modernization](/solutions/code-modernization)
  Code modernization

- Coding

  [Coding](/solutions/coding)
  Coding

- Customer support

  [Customer support](/solutions/customer-support)
  Customer support

- Education

  [Education](/solutions/education)
  Education

- Financial services

  [Financial services](/solutions/financial-services)
  Financial services

- Government

  [Government](/solutions/government)
  Government

- Healthcare

  [Healthcare](/solutions/healthcare)
  Healthcare

- Life sciences

  [Life sciences](/solutions/life-sciences)
  Life sciences

- Nonprofits

  [Nonprofits](/solutions/nonprofits)
  Nonprofits

Claude Platform

- Overview

  [Overview](/platform/api)
  Overview

- Developer docs

  [Developer docs](https://platform.claude.com/docs)
  Developer docs

- Pricing

  [Pricing](https://claude.com/pricing#api)
  Pricing

- Marketplace

  [Marketplace](/platform/marketplace)
  Marketplace

- Amazon Bedrock

  [Amazon Bedrock](/partners/amazon-bedrock)
  Amazon Bedrock

- Google Cloud’s Vertex AI

  [Google Cloud’s Vertex AI](/partners/google-cloud-vertex-ai)
  Google Cloud’s Vertex AI

- Microsoft Foundry

  [Microsoft Foundry](/partners/microsoft-foundry)
  Microsoft Foundry

- Regional compliance

  [Regional compliance](/regional-compliance)
  Regional compliance

- Console login

  [Console login](../04-API-Reference/Other/platform-claude-com.md)
  Console login

Resources

- Blog

  [Blog](/blog)
  Blog

- Claude partner network

  [Claude partner network](/partners)
  Claude partner network

- Community

  [Community](/community)
  Community

- Connectors

  [Connectors](/connectors)
  Connectors

- Courses

  [Courses](https://www.anthropic.com/learn)
  Courses

- Customer stories

  [Customer stories](/customers)
  Customer stories

- Engineering at Anthropic

  [Engineering at Anthropic](https://www.anthropic.com/engineering)
  Engineering at Anthropic

- Events

  [Events](https://www.anthropic.com/events)
  Events

- Plugins

  [Plugins](/plugins)
  Plugins

- Powered by Claude

  [Powered by Claude](/partners/powered-by-claude)
  Powered by Claude

- Service partners

  [Service partners](/partners/services)
  Service partners

- Startups program

  [Startups program](/programs/startups)
  Startups program

- Tutorials

  [Tutorials](/resources/tutorials)
  Tutorials

- Use cases

  [Use cases](/resources/use-cases)
  Use cases

Company

- Anthropic

  [Anthropic](https://www.anthropic.com/)
  Anthropic

- Careers

  [Careers](https://www.anthropic.com/careers)
  Careers

- Economic Futures

  [Economic Futures](https://www.anthropic.com/economic-futures)
  Economic Futures

- Research

  [Research](https://www.anthropic.com/research)
  Research

- News

  [News](https://www.anthropic.com/news)
  News

- Responsible Scaling Policy

  [Responsible Scaling Policy](../19-Reference/announcing-our-updated-responsible-scaling-policy-anthropic.md)
  Responsible Scaling Policy

- Security and compliance

  [Security and compliance](https://trust.anthropic.com/)
  Security and compliance

- Transparency

  [Transparency](https://anthropic.com/transparency)
  Transparency

Help and security

- Availability

  [Availability](https://www.anthropic.com/supported-countries)
  Availability

- Status

  [Status](https://status.anthropic.com/)
  Status

- Support center

  [Support center](https://support.claude.com/en/)
  Support center

Terms and policies

Privacy choices

### Cookie settings

We use cookies to deliver and improve our services, analyze site usage, and if you agree, to customize or personalize your experience and market our services to you. You can read our Cookie Policy [here](https://www.anthropic.com/legal/cookies).

Customize cookie settings

Reject all cookies

Accept all cookies

###### Necessary

Enables security and basic functionality.

Required

###### Analytics

Enables tracking of site performance.

Off

###### Marketing

Enables ads personalization and tracking.

Off

Save preferences

Privacy policy

[Privacy policy](https://www.anthropic.com/legal/privacy)

Privacy policy

Responsible disclosure policy

[Responsible disclosure policy](https://www.anthropic.com/responsible-disclosure-policy)

Responsible disclosure policy

Terms of service: Commercial

[Terms of service: Commercial](https://www.anthropic.com/legal/commercial-terms)

Terms of service: Commercial

Terms of service: Consumer

[Terms of service: Consumer](https://www.anthropic.com/legal/consumer-terms)

Terms of service: Consumer

Usage policy

[Usage policy](https://www.anthropic.com/legal/aup)

Usage policy

[x.com](https://x.com/claudeai)

x.com

[LinkedIn](https://www.linkedin.com/showcase/claude/)

LinkedIn

[YouTube](https://www.youtube.com/@anthropic-ai)

YouTube

[Instagram](https://www.instagram.com/claudeai)

Instagram

English (US)

[English (US)](/resources/tutorials/getting-started-with-claude-for-life-sciences)

[日本語 (Japan)](/ja-jp)

[Deutsch (Germany)](/de-de)

[Français (France)](/fr-fr)

[한국어 (South Korea)](/ko-kr)


---
## getting-started-with-claude.md

# Getting started with Claude


## What is Claude?

Claude is a large language model (LLM) built by Anthropic. It's trained to be a helpful, honest, and harmless assistant with a conversational tone.

## How to access Claude

You can access Claude through several platforms:

- **Web**: Visit [claude.ai](https://claude.ai/) to chat with Claude in a web browser.

- **Desktop**: [Download Claude Desktop](https://claude.ai/download) for Mac or Windows.

- **Mobile**: Download Claude for iOS or Android to chat on your mobile device.

## Supported locations

You must be in one of our [supported locations](https://support.claude.com/en/articles/8461763-where-can-i-access-claude) to access Claude.

## Is there an age requirement to use Claude?

You must be at least 18 years old to use our services.

## How to talk to Claude

### What is a prompt?

You use **prompts** to communicate with Claude. The best approach is to speak to Claude like you would a coworker or friend - naturally and conversationally. Your prompts can range from simple questions to complex requests:

- **Simple questions**: "How do I hang a picture frame in my room?"

- **Complex requests**: Multi-step projects, analysis, creative writing, coding, or technical tasks.

### Using the Claude chat interface

Type your prompt into the chat interface and click the submit button to start a conversation with Claude. You can click the "+" button in the lower left or type "/" to view additional options and commands:


------------------------------------------------------------------------

## Understanding Claude's capabilities

### Which model am I talking to?

The model you're currently chatting with is displayed below your text input. Free users can’t adjust this, but users on paid plans can toggle between different models using the model selector.

### Can I chat with Claude in different languages?

Claude has extensive training in English and performs well in many other common languages. It also has some ability to communicate in less common languages and has extensive knowledge of programming languages.

For instructions to select a language in your settings, see **[How to use Claude in your preferred language](../22-Safety-Policy/how-to-use-claude-in-your-preferred-language.md).**

### Are there any usage limits or limits on chat length?

While using the free Claude plan, there is a session-based usage limit that will reset every five hours. Also, the number of messages you can send will vary based on demand, and we may impose other types of usage limits to ensure fair access to all users. Claude will notify you when you’ve reached your limit, or if your prompt exceeds the available context window.

For more information about usage and length limits, refer to **[Understanding usage and length limits](../15-Claude-AI-Features/understanding-usage-and-length-limits.md)**.

## How do I increase my usage limits?

We also have several paid subscriptions that offer additional usage. For more information, view our guide on **[Choosing a Claude plan](../17-Billing-Plans/choosing-a-claude-plan.md)**.

------------------------------------------------------------------------

## Tips for getting started

1.  **Start simple**: Begin with straightforward questions to get familiar with how Claude responds.

2.  **Be specific**: The more specific your request, the better Claude can assist you.

3.  **Iterate**: Don't hesitate to refine your prompts or ask follow-up questions.

4.  **Explore**: Try different types of tasks - from having Claude answer basic questions to using it as a collaboration partner for more involved projects.

------------------------------------------------------------------------

## Next steps

Once you've started using Claude, you can:

- **[Customize your appearance settings](../15-Claude-AI-Features/customizing-your-appearance-settings.md)**

- **[Explore Claude’s personalization features](https://support.claude.com/en/articles/10185728-understanding-claude-s-personalization-features)**

- Learn more about designing effective prompts in our [**prompt engineering documentation**](../10-Prompting-Guides/build-with-claude-prompt-engineering-overview.md).

- For additional features and more usage, consider **[upgrading to a paid plan](../17-Billing-Plans/choosing-a-claude-plan.md)**.


---
## intro-09000d9804.md

# Intro to Claude

Claude is a highly performant, trustworthy, and intelligent AI platform built by Anthropic. Claude excels at tasks involving language, reasoning, analysis, coding, and more.

---

<Tip>

The latest generation of Claude models:

**Claude Opus 4.7** - Our most capable model for complex reasoning and agentic coding, with a step-change jump over Claude Opus 4.6. [Learn more](https://www.anthropic.com/news/claude-opus-4-7).

**Claude Sonnet 4.6** - Frontier intelligence at scale—built for coding, agents, and enterprise workflows. [Learn more](../19-Reference/introducing-sonnet-4-6-anthropic.md).

**Claude Haiku 4.5** - Fastest model with near-frontier intelligence. [Learn more](../19-Reference/introducing-claude-haiku-4-5-anthropic.md).

</Tip>

<Note>
Looking to chat with Claude? Visit [claude.ai](https://www.claude.ai).
</Note>

Anthropic offers two ways to build with Claude, each suited to different use cases:

| | Messages API | Claude Managed Agents |
|---|---|---|
| **What it is** | Direct model prompting access | Pre-built, configurable agent harness that runs in managed infrastructure |
| **Best for** | Custom agent loops and fine-grained control | Long-running tasks and asynchronous work |
| **Learn more** | [Messages API docs](/docs/en/build-with-claude/working-with-messages) | [Claude Managed Agents docs](/docs/en/managed-agents/overview) |

## Recommended path for new developers

Follow these steps to go from zero to a working Claude integration.

<Steps>
  <Step title="Make your first API call">
    Set up your environment, install an SDK, and send your first message to Claude.

    [Go to the quickstart](/docs/en/get-started)
  </Step>
  <Step title="Understand the Messages API">
    Learn the core request and response structure, including multi-turn conversations, system prompts, and stop reasons.

    [Read the Messages API guide](/docs/en/build-with-claude/working-with-messages)
  </Step>
  <Step title="Choose the right model">
    Compare Claude models by capability and cost to pick the best fit for your use case.

    [See the models overview](/docs/en/about-claude/models/overview)
  </Step>
  <Step title="Explore features and tools">
    Discover what Claude can do: extended thinking, web search, file handling, structured outputs, and more.

    [Browse the features overview](/docs/en/build-with-claude/overview)
  </Step>
</Steps>

---

## Develop with Claude

Anthropic provides developer tools to help you build and scale applications with Claude.

<CardGroup cols={3}>
  <Card title="Developer Console" icon="computer" href="/">
    Prototype and test prompts in your browser with the Workbench and prompt generator.
  </Card>
  <Card title="API Reference" icon="code" href="/docs/en/api/overview">
    Explore the full Claude API and client SDK documentation.
  </Card>
  <Card title="Claude Cookbook" icon="chef-hat" href="https://platform.claude.com/cookbooks">
    Learn with interactive Jupyter notebooks covering PDFs, embeddings, and more.
  </Card>
</CardGroup>

---

## Key capabilities

Claude can assist with many tasks that involve text, code, and images.

<CardGroup cols={2}>
  <Card title="Text and code generation" icon="text-aa" href="/docs/en/build-with-claude/overview">
    Summarize text, answer questions, extract data, translate text, and explain and generate code.
  </Card>
  <Card title="Vision" icon="image" href="/docs/en/build-with-claude/vision">
    Process and analyze visual input and generate text and code from images.
  </Card>
</CardGroup>

---

## Support

<CardGroup cols={2}>
  <Card title="Help Center" icon="help" href="https://support.claude.com/en/">
    Find answers to frequently asked account and billing questions.
  </Card>

  <Card title="Service Status" icon="chart" href="https://status.claude.com">
    Check the status of Anthropic services.
  </Card>
</CardGroup>

---
## intro.md

# Intro to Claude

Claude is a highly performant, trustworthy, and intelligent AI platform built by Anthropic. Claude excels at tasks involving language, reasoning, analysis, coding, and more.

## Latest Claude Models

**Claude Opus 4.6** - Our most intelligent model, and the world's best model for coding, enterprise agents, and professional work. [Learn more](https://www.anthropic.com/news/claude-opus-4-6).

**Claude Sonnet 4.6** - Frontier intelligence at scale—built for coding, agents, and enterprise workflows. [Learn more](../19-Reference/introducing-sonnet-4-6-anthropic.md).

**Claude Haiku 4.5** - Fastest model with near-frontier intelligence. [Learn more](../19-Reference/introducing-claude-haiku-4-5-anthropic.md).

Looking to chat with Claude? Visit [claude.ai](https://www.claude.ai).

## Recommended Path for New Developers

Follow these steps to go from zero to a working Claude integration.

1. **Make your first API call** - Set up your environment, install an SDK, and send your first message to Claude. [Go to the quickstart](/docs/en/get-started)

2. **Understand the Messages API** - Learn the core request and response structure, including multi-turn conversations, system prompts, and stop reasons. [Read the Messages API guide](/docs/en/build-with-claude/working-with-messages)

3. **Choose the right model** - Compare Claude models by capability and cost to pick the best fit for your use case. [See the models overview](/docs/en/about-claude/models/overview)

4. **Explore features and tools** - Discover what Claude can do: extended thinking, web search, file handling, structured outputs, and more. [Browse the features overview](/docs/en/build-with-claude/overview)

## Develop with Claude

Anthropic provides developer tools to help you build and scale applications with Claude.

**Developer Console** - Prototype and test prompts in your browser with the Workbench and prompt generator.

**API Reference** - Explore the full Claude API and client SDK documentation.

**Claude Cookbook** - Learn with interactive Jupyter notebooks covering PDFs, embeddings, and more.

## Key Capabilities

Claude can assist with many tasks that involve text, code, and images.

**Text and code generation** - Summarize text, answer questions, extract data, translate text, and explain and generate code.

**Vision** - Process and analyze visual input and generate text and code from images.

## Support

**Help Center** - Find answers to frequently asked account and billing questions.

**Service Status** - Check the status of Anthropic services.


---
## introduction-to-claude-skills.md

# Introduction to Claude Skills

Learn how to use Claude's Skills feature to create professional documents, analyze data, and automate business workflows with Excel, PowerPoint, and PDF generation.

> **See it in action:** The Skills you'll learn about power Claude's file creation capabilities! Check out **[Claude Creates Files](../19-Reference/claude-can-now-create-and-edit-files-claude.md)** to see how these Skills enable Claude to create and edit documents directly in Claude.ai.

## Table of Contents

1. [Setup & Installation](#setup)
2. [Understanding Skills](#understanding)
3. [Discovering Available Skills](#discovering)
4. [Quick Start: Excel](#excel-quickstart)
5. [Quick Start: PowerPoint](#powerpoint-quickstart)
6. [Quick Start: PDF](#pdf-quickstart)
7. [Troubleshooting](#troubleshooting)

## 1. Setup & Installation {#setup}

### Prerequisites

Before starting, make sure you have:

- Python 3.8 or higher
- An Anthropic API key from [console.anthropic.com](https://console.anthropic.com/)

### Environment Setup (First Time Only)

**If you haven't set up your environment yet**, follow these steps:

#### Step 1: Create Virtual Environment

``` bash
# Navigate to the skills directory
cd /path/to/claude-cookbooks/skills

# Create virtual environment
python -m venv venv

# Activate it
source venv/bin/activate  # On macOS/Linux
# OR
venv\Scripts\activate     # On Windows
```

#### Step 2: Install Dependencies

``` bash
# With venv activated, install requirements
pip install -r requirements.txt
```

#### Step 3: Select Kernel in VSCode/Jupyter

**In VSCode:**

1. Open this notebook
2. Click the kernel picker in the top-right (e.g., "Python 3.11.x")
3. Select "Python Environments..."
4. Choose the `./venv/bin/python` interpreter

**In Jupyter:**

1. From the Kernel menu → Change Kernel
2. Select the kernel matching your venv

#### Step 4: Configure API Key

``` bash
# Copy the example file
cp .env.example .env

# Edit .env and add your API key:
# ANTHROPIC_API_KEY=sk-ant-api03-...
```

### Quick Installation Check

Run the cell below to verify your environment is set up correctly:

**If you see any ❌ or ⚠️ warnings above**, please complete the setup steps before continuing.

**If anthropic SDK version is too old (needs 0.71.0 or later):**

``` bash
pip install anthropic>=0.71.0
```

Then **restart the Jupyter kernel** to pick up the new version.

### API Configuration

Now let's load the API key and configure the client:

**⚠️ Important**: Create a `.env` file in the skills directory:

``` bash
# Copy the example file
cp ../.env.example ../.env
```

Then edit `../.env` to add your Anthropic API key.

``` python
import os
import sys
from pathlib import Path

# Add parent directory to path for imports
sys.path.insert(0, str(Path.cwd().parent))


from anthropic import Anthropic
from dotenv import load_dotenv

# Import our file utilities
from file_utils import (
    download_all_files,
    extract_file_ids,
    get_file_info,
    print_download_summary,
)

# Load environment variables from parent directory
load_dotenv(Path.cwd().parent / ".env")

API_KEY = os.getenv("ANTHROPIC_API_KEY")
MODEL = os.getenv("ANTHROPIC_MODEL", "claude-sonnet-4-5")

if not API_KEY:
    raise ValueError(
        "ANTHROPIC_API_KEY not found. Copy ../.env.example to ../.env and add your API key."
    )

# Initialize client
# Note: We'll add beta headers per-request when using Skills
client = Anthropic(api_key=API_KEY)

# Create outputs directory if it doesn't exist
OUTPUT_DIR = Path.cwd().parent / "outputs"
OUTPUT_DIR.mkdir(exist_ok=True)

print("✓ API key loaded")
print(f"✓ Using model: {MODEL}")
print(f"✓ Output directory: {OUTPUT_DIR}")
print("\n📝 Note: Beta headers will be added per-request when using Skills")
```

### Test Connection

Let's verify our API connection works:

``` python
# Simple test to verify API connection
test_response = client.messages.create(
    model=MODEL,
    max_tokens=100,
    messages=[
        {
            "role": "user",
            "content": "Say 'Connection successful!' if you can read this.",
        }
    ],
)

print("API Test Response:")
print(test_response.content[0].text)
print(
    f"\n✓ Token usage: {test_response.usage.input_tokens} in, {test_response.usage.output_tokens} out"
)
```

## 2. Understanding Skills {#understanding}

### What are Skills?

**Skills** are organized packages of instructions, executable code, and resources that give Claude specialized capabilities for specific tasks. Think of them as "expertise packages" that Claude can discover and load dynamically.

📖 Read our engineering blog post on [Equipping agents for the real world with Skills](https://www.anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills)

### Why Skills Matter

After learning about MCPs (Model Context Protocol) and tools, you might wonder why Skills are important:

- **Skills are higher-level** than individual tools - they combine instructions, code, and resources
- **Skills are composable** - multiple skills work together seamlessly
- **Skills are efficient** - progressive disclosure means you only pay for what you use
- **Skills include proven code** - helper scripts that work reliably, saving time and reducing errors

### Key Benefits

- **Expert-level Performance**: Deliver professional results without the learning curve
- **Proven Helper Scripts**: Skills contain tested, working code that Claude can use immediately
- **Organizational Knowledge**: Package company workflows and best practices
- **Cost Efficiency**: Progressive disclosure minimizes token usage
- **Reliability**: Pre-tested scripts mean fewer errors and consistent results
- **Time Savings**: Claude uses existing solutions instead of generating code from scratch
- **Composable**: Multiple skills work together for complex workflows

### Progressive Disclosure Architecture

Skills use a three-tier loading model:

![Progressive Disclosure - How Skills Load](../assets/prog-disc-1.png)

1. **Metadata** (name: 64 chars, description: 1024 chars): Claude sees skill name and description
2. **Full Instructions** (<5k tokens): Loaded when skill is relevant
3. **Linked Files**: Additional resources loaded only if needed

![Progressive Disclosure Stages](../assets/prog-disc-2.png)

This keeps operations efficient while providing deep expertise on demand. Initially, Claude sees just the metadata from the YAML frontmatter of SKILL.md. Only when a skill is relevant does Claude load the full contents, including any helper scripts and resources.

### Skill Types

| Type | Description | Example |
|------|-------------|---------|
| **Anthropic-Managed** | Pre-built skills maintained by Anthropic | `xlsx`, `pptx`, `pdf`, `docx` |
| **Custom** | User-defined skills for specific workflows | Brand guidelines, financial models |

### Skills Conceptual Overview

![Skills Conceptual Diagram](../assets/skills-conceptual-diagram.png)

This diagram illustrates:

- **Skill Directory Structure**: How Skills are organized with SKILL.md and supporting files
- **YAML Frontmatter**: The metadata that Claude sees initially
- **Progressive Loading**: How Skills are discovered and loaded on-demand
- **Composability**: Multiple Skills working together in a single request

### How Skills Work with Code Execution

Skills require the **code execution** tool to be enabled. Here's the typical workflow:

``` python
# Use client.beta.messages.create() for Skills support
response = client.beta.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=4096,
    container={
        "skills": [
            {"type": "anthropic", "skill_id": "xlsx", "version": "latest"}
        ]
    },
    tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
    messages=[{"role": "user", "content": "Create an Excel file..."}],
    # Use betas parameter instead of extra_headers
    betas=["code-execution-2025-08-25", "files-api-2025-04-14", "skills-2025-10-02"]
)
```

**What happens:**

1. Claude receives your request with the xlsx skill loaded
2. Claude uses code execution to create the file
3. The response includes a `file_id` for the created file
4. You use the **Files API** to download the file

**Important: Beta API**

- Use `client.beta.messages.create()` (not `client.messages.create()`)
- The `container` parameter is only available in the beta API
- Use the `betas` parameter to enable beta features:
  - `code-execution-2025-08-25` - Enables code execution
  - `files-api-2025-04-14` - Required for downloading files
  - `skills-2025-10-02` - Enables Skills feature

⚠️ **Note**: When using Skills, you MUST include the code_execution tool in your request.

### Token Usage Optimization

Skills dramatically reduce token usage compared to providing instructions in prompts:

| Approach | Token Cost | Performance |
|----------|-----------|-------------|
| Manual instructions | 5,000-10,000 tokens/request | Variable quality |
| Skills (metadata only) | Minimal (just name/description) | Expert-level |
| Skills (full load) | ~5,000 tokens when skill is used | Expert-level |

**The Big Win:** You can pack multiple skills into your prompt without bloating it. Each skill only costs you the metadata (name + description) until you actually use it.

**Example**: Creating an Excel file with formatting

- Without Skills: ~8,000 tokens to explain all Excel features upfront
- With Skills: Minimal metadata overhead initially, ~5,000 tokens only when Excel skill is invoked
- **Key Insight**: The 98% savings applies to the initial context. Once you use a skill, the full instructions are loaded.

**Additional Benefits:**

- Skills contain helper scripts that are known to work, improving reliability
- Claude saves time by using proven code patterns instead of generating from scratch
- You get more consistent, professional results

### ⏱️ Expected Generation Times

**⚠️ IMPORTANT**: Document generation with Skills requires code execution and file creation, which takes time. Be patient and let cells complete.

**Observed generation times:**

- **Excel files**: ~2 minutes (with charts and formatting)
- **PowerPoint presentations**: ~1-2 minutes (simple 2-slide presentations with charts)
- **PDF documents**: ~40-60 seconds (simple documents)

**What to expect:**

- The cell will show `[*]` while running
- You may see "Executing..." status for 1-2 minutes
- **Do not interrupt the cell** - let it complete fully

**💡 Recommendations:**

1. **Start simple**: Begin with minimal examples to verify your setup
2. **Gradually increase complexity**: Add features incrementally
3. **Be patient**: Operations typically take 40 seconds to 2 minutes
4. **Note**: Very complex documents may take longer - keep examples focused

## 3. Discovering Available Skills {#discovering}

### List All Built-in Skills

Let's discover what Anthropic-managed skills are available:

``` python
# List all available Anthropic skills
# Note: Skills API requires the skills beta header
client_with_skills_beta = Anthropic(
    api_key=API_KEY, default_headers={"anthropic-beta": "skills-2025-10-02"}
)

skills_response = client_with_skills_beta.beta.skills.list(source="anthropic")

print("Available Anthropic-Managed Skills:")
print("=" * 80)

for skill in skills_response.data:
    print(f"\n📦 Skill ID: {skill.id}")
    print(f"   Title: {skill.display_title}")
    print(f"   Latest Version: {skill.latest_version}")
    print(f"   Created: {skill.created_at}")

    # Get version details
    try:
        version_info = client_with_skills_beta.beta.skills.versions.retrieve(
            skill_id=skill.id, version=skill.latest_version
        )
        print(f"   Name: {version_info.name}")
        print(f"   Description: {version_info.description}")
    except Exception as e:
        print(f"   (Unable to fetch version details: {e})")

print(f"\n\n✓ Found {len(skills_response.data)} Anthropic-managed skills")
```

### Understanding Skill Metadata

Each skill has:

- **skill_id**: Unique identifier (e.g., "xlsx", "pptx")
- **version**: Version number or "latest"
- **name**: Human-readable name
- **description**: What the skill does
- **directory**: Skill's folder structure

### Versioning Strategy

- Use `"latest"` for Anthropic skills (recommended)
- Anthropic updates skills automatically
- Pin specific versions for production stability
- Custom skills use epoch timestamps for versions

## 4. Quick Start: Excel {#excel-quickstart}

### Example: Monthly Budget Spreadsheet

We'll create a simple budget spreadsheet with:

- Income and expense categories
- Formulas for totals
- Basic formatting

**⏱️ Note**: Excel generation typically takes **1-2 minutes** (with charts and formatting). The cell will show `[*]` while running - be patient!

``` python
# Create an Excel budget spreadsheet
excel_response = client.beta.messages.create(  # Note: Using beta.messages for Skills support
    model=MODEL,
    max_tokens=4096,
    container={"skills": [{"type": "anthropic", "skill_id": "xlsx", "version": "latest"}]},
    tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
    messages=[
        {
            "role": "user",
            "content": """Create a monthly budget Excel spreadsheet with the following:

Income:
- Salary: $5,000
- Freelance: $1,200
- Investments: $300

Expenses:
- Rent: $1,500
- Utilities: $200
- Groceries: $600
- Transportation: $300
- Entertainment: $400
- Savings: $1,000

Include:
1. Formulas to calculate total income and total expenses
2. A formula for net savings (income - expenses)
3. Format currency values properly
4. Add a simple column chart showing income vs expenses
5. Use professional formatting with headers
""",
        }
    ],
    # Use betas parameter for beta features
    betas=["code-execution-2025-08-25", "files-api-2025-04-14", "skills-2025-10-02"],
)

print("Excel Response:")
print("=" * 80)
for content in excel_response.content:
    if content.type == "text":
        print(content.text)
    elif content.type == "tool_use":
        print(f"\n🔧 Tool: {content.name}")
        if hasattr(content, "input"):
            print(f"   Input preview: {str(content.input)[:200]}...")

print("\n\n📊 Token Usage:")
print(f"   Input: {excel_response.usage.input_tokens}")
print(f"   Output: {excel_response.usage.output_tokens}")
```

### Download the Excel File

Now let's extract the file_id and download the generated Excel file:

``` python
# Extract file IDs from the response
file_ids = extract_file_ids(excel_response)

if file_ids:
    print(f"✓ Found {len(file_ids)} file(s)\n")

    # Download all files
    results = download_all_files(
        client, excel_response, output_dir=str(OUTPUT_DIR), prefix="budget_"
    )

    # Print summary
    print_download_summary(results)

    # Show file details
    for file_id in file_ids:
        info = get_file_info(client, file_id)
        if info:
            print("\n📄 File Details:")
            print(f"   Filename: {info['filename']}")
            print(f"   Size: {info['size'] / 1024:.1f} KB")
            print(f"   Created: {info['created_at']}")
else:
    print("❌ No files found in response")
    print("\nDebug: Response content types:")
    for i, content in enumerate(excel_response.content):
        print(f"  {i}. {content.type}")
```

**✨ What just happened?**

1. Claude used the `xlsx` skill to create a professional Excel file
2. The skill handled all Excel-specific formatting and formulas
3. The file was created in Claude's code execution environment
4. We extracted the `file_id` from the response
5. We downloaded the file using the Files API
6. The file is now saved in `outputs/budget_*.xlsx`

Open the file in Excel to see the results!

## 5. Quick Start: PowerPoint {#powerpoint-quickstart}

Now let's create a PowerPoint presentation using the `pptx` skill.

### Example: Simple Revenue Presentation

**Note**: This is intentionally kept simple (2 slides, 1 chart) to minimize generation time and demonstrate the core functionality.

``` python
# Create a PowerPoint presentation
pptx_response = client.beta.messages.create(
    model=MODEL,
    max_tokens=4096,
    container={"skills": [{"type": "anthropic", "skill_id": "pptx", "version": "latest"}]},
    tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
    messages=[
        {
            "role": "user",
            "content": """Create a simple 2-slide PowerPoint presentation:

Slide 1: Title slide
- Title: "Q3 2025 Results"
- Subtitle: "Acme Corporation"

Slide 2: Revenue Overview
- Title: "Quarterly Revenue"
- Add a simple column chart showing:
  - Q1: $12M
  - Q2: $13M
  - Q3: $14M

Use clean, professional formatting.
""",
        }
    ],
    betas=["code-execution-2025-08-25", "files-api-2025-04-14", "skills-2025-10-02"],
)

print("PowerPoint Response:")
print("=" * 80)
for content in pptx_response.content:
    if content.type == "text":
        print(content.text)

print("\n\n📊 Token Usage:")
print(f"   Input: {pptx_response.usage.input_tokens}")
print(f"   Output: {pptx_response.usage.output_tokens}")
```

### Download the PowerPoint File

``` python
# Download the PowerPoint file
file_ids = extract_file_ids(pptx_response)

if file_ids:
    results = download_all_files(
        client, pptx_response, output_dir=str(OUTPUT_DIR), prefix="q3_review_"
    )

    print_download_summary(results)

    print("\n✅ Open the presentation in PowerPoint or Google Slides to view!")
else:
    print("❌ No files found in response")
```

## 6. Quick Start: PDF {#pdf-quickstart}

**⏱️ Note**: PDF generation typically takes **40-60 seconds** for simple documents. The cell will show `[*]` while running - be patient!

### Example: Simple Receipt

**Note**: This is intentionally kept simple to ensure clean formatting.

``` python
# Create a PDF receipt
pdf_response = client.beta.messages.create(
    model=MODEL,
    max_tokens=4096,
    container={"skills": [{"type": "anthropic", "skill_id": "pdf", "version": "latest"}]},
    tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
    messages=[
        {
            "role": "user",
            "content": """Create a simple receipt PDF:

RECEIPT

Acme Corporation
Date: January 15, 2025
Receipt #: RCT-2025-001

Customer: Jane Smith

Items:
- Product A: $50.00
- Product B: $75.00
- Product C: $25.00

Subtotal: $150.00
Tax (8%): $12.00
Total: $162.00

Thank you for your business!

Use simple, clean formatting with clear sections.
""",
        }
    ],
    betas=["code-execution-2025-08-25", "files-api-2025-04-14", "skills-2025-10-02"],
)

print("PDF Response:")
print("=" * 80)
for content in pdf_response.content:
    if content.type == "text":
        print(content.text)

print("\n\n📊 Token Usage:")
print(f"   Input: {pdf_response.usage.input_tokens}")
print(f"   Output: {pdf_response.usage.output_tokens}")
```

### Download and Verify the PDF

``` python
# Download the PDF file
file_ids = extract_file_ids(pdf_response)

if file_ids:
    results = download_all_files(
        client, pdf_response, output_dir=str(OUTPUT_DIR), prefix="receipt_"
    )

    print_download_summary(results)

    # Verify PDF integrity
    for result in results:
        if result["success"]:
            file_path = result["output_path"]
            file_size = result["size"]

            # Basic PDF validation
            with open(file_path, "rb") as f:
                header = f.read(5)
                if header == b"%PDF-":
                    print(f"\n✅ PDF file is valid: {file_path}")
                    print(f"   File size: {file_size / 1024:.1f} KB")
                else:
                    print(f"\n⚠️ File may not be a valid PDF: {file_path}")
else:
    print("❌ No files found in response")
```

## 7. Troubleshooting {#troubleshooting}

### Common Issues and Solutions

### Issue 1: API Key Not Found

**Error:**

```
ValueError: ANTHROPIC_API_KEY not found
```

**Solution:**

1. Ensure `.env` file exists in the parent directory
2. Check that `ANTHROPIC_API_KEY=sk-ant-api03-...` is set
3. Restart the Jupyter kernel after creating/editing `.env`

### Issue 2: Container Parameter Not Recognized

**Error:**

```
TypeError: Messages.create() got an unexpected keyword argument 'container'
```

**Solution:** Use `client.beta.messages.create()` instead of `client.messages.create()`:

``` python
# ✅ Correct - use beta.messages
response = client.beta.messages.create(
    model=MODEL,
    container={"skills": [...]},
    tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
    messages=[...],
    betas=["code-execution-2025-08-25", "files-api-2025-04-14", "skills-2025-10-02"]
)

# ❌ Incorrect - regular messages doesn't support container
response = client.messages.create(
    model=MODEL,
    container={"skills": [...]},  # Error!
    messages=[...]
)
```

### Issue 3: Skills Beta Requires Code Execution Tool

**Error:**

```
BadRequestError: Skills beta requires the code_execution tool to be included in the request.
```

**Solution:** When using Skills, you MUST include the code_execution tool:

``` python
# ✅ Correct
response = client.beta.messages.create(
    model=MODEL,
    tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
    messages=[...],
    betas=["...", "skills-2025-10-02"]
)

# ❌ Incorrect - missing code_execution tool
response = client.beta.messages.create(
    model=MODEL,
    messages=[...],
    betas=["...", "skills-2025-10-02"]
)
```

### Issue 4: No Files Found in Response

**Error:**

```
❌ No files found in response
```

**Solution:**

1. Check that code execution tool is included in the request
2. Verify the skill was loaded (check response content)
3. Ensure the task actually requires file creation
4. Look for error messages in the response text

### Issue 5: File Download Failed

**Error:**

```
Error retrieving file: File not found
```

**Solution:**

1. Files may have a limited lifetime on Anthropic's servers
2. Download files immediately after creation
3. Check file_id is correctly extracted from response
4. Verify Files API beta is included in betas list

### Token Optimization Tips

1. **Use "latest" version** for Anthropic skills - automatically optimized
2. **Batch operations** - Create multiple files in one conversation when possible
3. **Reuse containers** - Use `container.id` from previous responses to avoid reloading skills
4. **Be specific** - Clear instructions mean fewer iterations

### API Rate Limiting

If you encounter rate limits:

- Implement exponential backoff for retries
- Use batch processing for multiple files
- Consider upgrading your API tier for higher limits

## Next Steps

🎉 **Congratulations!** You've learned the basics of Claude Skills.

### See Skills in Action

Check out the official announcement to see how these Skills power Claude's file creation capabilities:

- **[Claude Creates Files](../19-Reference/claude-can-now-create-and-edit-files-claude.md)** - See how Skills enable Claude to create and edit Excel, PowerPoint, and PDF files directly

### Continue Learning

- **[Notebook 2: Financial Applications](02_skills_financial_applications.ipynb)** - Real-world business use cases with financial data
- **[Notebook 3: Custom Skills Development](03_skills_custom_development.ipynb)** - Build your own specialized skills

### Support Articles

- 📚 **[Teach Claude your way of working using Skills](https://support.claude.com/en/articles/12580051-teach-claude-your-way-of-working-using-skills)** - User guide for working with Skills
- 🛠️ **[How to create a skill with Claude through conversation](https://support.claude.com/en/articles/12599426-how-to-create-a-skill-with-claude-through-conversation)** - Interactive skill creation guide

### Resources

- [Claude API Documentation](https://docs.anthropic.com/en/api/messages)
- [Skills Documentation](https://docs.claude.com/en/docs/agents-and-tools/agent-skills/overview)
- [Skills Best Practices](https://docs.claude.com/en/docs/agents-and-tools/agent-skills/best-practices)
- [Files API Documentation](https://docs.claude.com/en/api/files-content)
- [Claude Support](https://support.claude.com)

### Try These Experiments

1. Start with simple one-line prompts to see Skills in action
2. Modify the budget example to include more categories
3. Create a presentation with your own data
4. Generate a PDF report combining text and tables
5. Use multiple skills together in a single request


---
## overview.md

> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Claude Code overview

> Learn about Claude Code, Anthropic's agentic coding tool that lives in your terminal and helps you turn ideas into code faster than ever before.

## Get started in 30 seconds

Prerequisites:

* A [Claude subscription](https://claude.com/pricing) (Pro, Max, Teams, or Enterprise) or [Claude Console](https://console.anthropic.com/) account

**Install Claude Code:**

To install Claude Code, use one of the following methods:

<Tabs>
  <Tab title="Native Install (Recommended)">
    **macOS, Linux, WSL:**

    ```bash  theme={null}
    curl -fsSL https://claude.ai/install.sh | bash
    ```

    **Windows PowerShell:**

    ```powershell  theme={null}
    irm https://claude.ai/install.ps1 | iex
    ```

    **Windows CMD:**

    ```batch  theme={null}
    curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd
    ```

    <Info>
      Native installations automatically update in the background to keep you on the latest version.
    </Info>
  </Tab>

  <Tab title="Homebrew">
    ```sh  theme={null}
    brew install --cask claude-code
    ```

    <Info>
      Homebrew installations do not auto-update. Run `brew upgrade claude-code` periodically to get the latest features and security fixes.
    </Info>
  </Tab>

  <Tab title="WinGet">
    ```powershell  theme={null}
    winget install Anthropic.ClaudeCode
    ```

    <Info>
      WinGet installations do not auto-update. Run `winget upgrade Anthropic.ClaudeCode` periodically to get the latest features and security fixes.
    </Info>
  </Tab>
</Tabs>

**Start using Claude Code:**

```bash  theme={null}
cd your-project
claude
```

You'll be prompted to log in on first use. That's it! [Continue with Quickstart (5 minutes) →](quickstart-claude-code-docs-a21b84bdea.md)

<Tip>
  See [advanced setup](advanced-setup-claude-code-docs-0526bc1300.md) for installation options, manual updates, or uninstallation instructions. Visit [troubleshooting](../21-Account-Support/troubleshooting-claude-code-docs-3f3657ed0f.md) if you hit issues.
</Tip>

## What Claude Code does for you

* **Build features from descriptions**: Tell Claude what you want to build in plain English. It will make a plan, write the code, and ensure it works.
* **Debug and fix issues**: Describe a bug or paste an error message. Claude Code will analyze your codebase, identify the problem, and implement a fix.
* **Navigate any codebase**: Ask anything about your team's codebase, and get a thoughtful answer back. Claude Code maintains awareness of your entire project structure, can find up-to-date information from the web, and with [MCP](../06-MCP-Tools/General/connect-claude-code-to-tools-via-mcp-claude-code-docs.md) can pull from external data sources like Google Drive, Figma, and Slack.
* **Automate tedious tasks**: Fix fiddly lint issues, resolve merge conflicts, and write release notes. Do all this in a single command from your developer machines, or automatically in CI.

## Why developers love Claude Code

* **Works in your terminal**: Not another chat window. Not another IDE. Claude Code meets you where you already work, with the tools you already love.
* **Takes action**: Claude Code can directly edit files, run commands, and create commits. Need more? [MCP](../06-MCP-Tools/General/connect-claude-code-to-tools-via-mcp-claude-code-docs.md) lets Claude read your design docs in Google Drive, update your tickets in Jira, or use *your* custom developer tooling.
* **Unix philosophy**: Claude Code is composable and scriptable. `tail -f app.log | claude -p "Slack me if you see any anomalies appear in this log stream"` *works*. Your CI can run `claude -p "If there are new text strings, translate them into French and raise a PR for @lang-fr-team to review"`.
* **Enterprise-ready**: Use the Claude API, or host on AWS or GCP. Enterprise-grade [security](../02-Claude-Code-CLI/security-claude-code-docs.md), [privacy](../22-Safety-Policy/data-usage-claude-code-docs-06b2864aaa.md), and [compliance](https://trust.anthropic.com/) is built-in.

## Use Claude Code everywhere

Claude Code works across your development environment: in your terminal, in your IDE, in the cloud, and in Slack.

* **[Terminal (CLI)](quickstart-claude-code-docs-a21b84bdea.md)**: the core Claude Code experience. Run `claude` in any terminal to start coding.
* **[Claude Code on the web](../02-Claude-Code-CLI/claude-code-on-the-web-69d53821d4.md)**: use Claude Code from your browser at [claude.ai/code](https://claude.ai/code) or the Claude iOS app, with no local setup required. Run tasks in parallel, work on repos you don't have locally, and review changes in a built-in diff view.
* **[Desktop app](../16-Mobile-Desktop/desktop.md)**: a standalone application with diff review, parallel sessions via git worktrees, and the ability to launch cloud sessions.
* **[VS Code](../03-IDE-Integrations/use-claude-code-in-vs-code-claude-code-docs-29143b6fee.md)**: a native extension with inline diffs, @-mentions, and plan review.
* **[JetBrains IDEs](../03-IDE-Integrations/jetbrains-4cf6bd8c22.md)**: a plugin for IntelliJ IDEA, PyCharm, WebStorm, and other JetBrains IDEs with IDE diff viewing and context sharing.
* **[GitHub Actions](../02-Claude-Code-CLI/claude-code-github-actions-claude-code-docs-0d633fbd8a.md)**: automate code review, issue triage, and other workflows in CI/CD with `@claude` mentions.
* **[GitLab CI/CD](../02-Claude-Code-CLI/claude-code-gitlab-ci-cd-claude-code-docs-fbcd915fee.md)**: event-driven automation for GitLab merge requests and issues.
* **[Slack](../02-Claude-Code-CLI/slack.md)**: mention Claude in Slack to route coding tasks to Claude Code on the web and get PRs back.
* **[Chrome](../02-Claude-Code-CLI/chrome.md)**: connect Claude Code to your browser for live debugging, design verification, and web app testing.

## Next steps

<CardGroup>
  <Card title="Quickstart" icon="rocket" href="/en/quickstart">
    See Claude Code in action with practical examples
  </Card>

  <Card title="Common workflows" icon="graduation-cap" href="/en/common-workflows">
    Step-by-step guides for common workflows
  </Card>

  <Card title="Troubleshooting" icon="wrench" href="/en/troubleshooting">
    Solutions for common issues with Claude Code
  </Card>

  <Card title="Desktop app" icon="laptop" href="/en/desktop">
    Run Claude Code as a standalone application
  </Card>
</CardGroup>

## Additional resources

<CardGroup>
  <Card title="About Claude Code" icon="sparkles" href="https://claude.com/product/claude-code">
    Learn more about Claude Code on claude.com
  </Card>

  <Card title="Build with the Agent SDK" icon="code-branch" href="https://docs.claude.com/en/docs/agent-sdk/overview">
    Create custom AI agents with the Claude Agent SDK
  </Card>

  <Card title="Host on AWS or GCP" icon="cloud" href="/en/third-party-integrations">
    Configure Claude Code with Amazon Bedrock or Google Vertex AI
  </Card>

  <Card title="Settings" icon="gear" href="/en/settings">
    Customize Claude Code for your workflow
  </Card>

  <Card title="Commands" icon="terminal" href="/en/cli-reference">
    Learn about CLI commands and controls
  </Card>

  <Card title="Reference implementation" icon="code" href="https://github.com/anthropics/claude-code/tree/main/.devcontainer">
    Clone our development container reference implementation
  </Card>

  <Card title="Security" icon="shield" href="/en/security">
    Discover Claude Code's safeguards and best practices for safe usage
  </Card>

  <Card title="Privacy and data usage" icon="lock" href="/en/data-usage">
    Understand how Claude Code handles your data
  </Card>
</CardGroup>


---
## quickstart-claude-code-docs-a21b84bdea.md

# Quickstart


Welcome to Claude Code!


This quickstart guide will have you using AI-powered coding assistance in a few minutes. By the end, you’ll understand how to use Claude Code for common development tasks.


[​](#before-you-begin)

Before you begin

Make sure you have:

- A terminal or command prompt open
  - If you’ve never used the terminal before, check out the [terminal guide](/docs/en/terminal-guide)
- A code project to work with
- A [Claude subscription](https://claude.com/pricing?utm_source=claude_code&utm_medium=docs&utm_content=quickstart_prereq) (Pro, Max, Team, or Enterprise), [Claude Console](https://console.anthropic.com/) account, or access through a [supported cloud provider](/docs/en/third-party-integrations)

This guide covers the terminal CLI. Claude Code is also available on the [web](https://claude.ai/code), as a [desktop app](/docs/en/desktop), in [VS Code](/docs/en/vs-code) and [JetBrains IDEs](/docs/en/jetbrains), in [Slack](/docs/en/slack), and in CI/CD with [GitHub Actions](/docs/en/github-actions) and [GitLab](/docs/en/gitlab-ci-cd). See [all interfaces](/docs/en/overview#use-claude-code-everywhere).


[​](#step-1-install-claude-code)

Step 1: Install Claude Code

To install Claude Code, use one of the following methods:

- Native Install (Recommended)

- Homebrew

- WinGet

**macOS, Linux, WSL:**

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

**Windows PowerShell:**

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

**Windows CMD:**

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

If you see `The token '&&' is not a valid statement separator`, you’re in PowerShell, not CMD. If you see `'irm' is not recognized as an internal or external command`, you’re in CMD, not PowerShell. Your prompt shows `PS C:\` when you’re in PowerShell and `C:\` without the `PS` when you’re in CMD.**Native Windows setups require [Git for Windows](https://git-scm.com/downloads/win).** Install it first if you don’t have it. WSL setups do not need it.

Native installations automatically update in the background to keep you on the latest version.

```python
brew install --cask claude-code
```

Homebrew offers two casks. `claude-code` tracks the stable release channel, which is typically about a week behind and skips releases with major regressions. `claude-code@latest` tracks the latest channel and receives new versions as soon as they ship.

Homebrew installations do not auto-update. Run `brew upgrade claude-code` or `brew upgrade claude-code@latest`, depending on which cask you installed, to get the latest features and security fixes.

```python
winget install Anthropic.ClaudeCode
```

WinGet installations do not auto-update. Run `winget upgrade Anthropic.ClaudeCode` periodically to get the latest features and security fixes.

You can also install with [apt, dnf, or apk](/docs/en/setup#install-with-linux-package-managers) on Debian, Fedora, RHEL, and Alpine.


[​](#step-2-log-in-to-your-account)

Step 2: Log in to your account

Claude Code requires an account to use. When you start an interactive session with the `claude` command, you’ll need to log in:

```python
claude
# You'll be prompted to log in on first use
```

```python
/login
# Follow the prompts to log in with your account
```

You can log in using any of these account types:

- [Claude Pro, Max, Team, or Enterprise](https://claude.com/pricing?utm_source=claude_code&utm_medium=docs&utm_content=quickstart_login) (recommended)
- [Claude Console](https://console.anthropic.com/) (API access with pre-paid credits). On first login, a “Claude Code” workspace is automatically created in the Console for centralized cost tracking.
- [Amazon Bedrock, Google Vertex AI, or Microsoft Foundry](/docs/en/third-party-integrations) (enterprise cloud providers)

Once logged in, your credentials are stored and you won’t need to log in again. To switch accounts later, use the `/login` command.


[​](#step-3-start-your-first-session)

Step 3: Start your first session

Open your terminal in any project directory and start Claude Code:

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

You’ll see the Claude Code welcome screen with your session information, recent conversations, and latest updates. Type `/help` for available commands or `/resume` to continue a previous conversation.

After logging in (Step 2), your credentials are stored on your system. Learn more in [Credential Management](/docs/en/authentication#credential-management).


[​](#step-4-ask-your-first-question)

Step 4: Ask your first question

Let’s start with understanding your codebase. Try one of these commands:

```python
what does this project do?
```

Claude will analyze your files and provide a summary. You can also ask more specific questions:

```python
what technologies does this project use?
```

```python
where is the main entry point?
```

```python
explain the folder structure
```

You can also ask Claude about its own capabilities:

```python
what can Claude Code do?
```

```python
how do I create custom skills in Claude Code?
```

```python
can Claude Code work with Docker?
```

Claude Code reads your project files as needed. You don’t have to manually add context.


[​](#step-5-make-your-first-code-change)

Step 5: Make your first code change

Now let’s make Claude Code do some actual coding. Try a simple task:

```python
add a hello world function to the main file
```

Claude Code will:

1.  Find the appropriate file
2.  Show you the proposed changes
3.  Ask for your approval
4.  Make the edit

Claude Code always asks for permission before modifying files. You can approve individual changes or enable “Accept all” mode for a session.


[​](#step-6-use-git-with-claude-code)

Step 6: Use Git with Claude Code

Claude Code makes Git operations conversational:

```python
what files have I changed?
```

```python
commit my changes with a descriptive message
```

You can also prompt for more complex Git operations:

```python
create a new branch called feature/quickstart
```

```python
show me the last 5 commits
```

```python
help me resolve merge conflicts
```


[​](#step-7-fix-a-bug-or-add-a-feature)

Step 7: Fix a bug or add a feature

Claude is proficient at debugging and feature implementation. Describe what you want in natural language:

```python
add input validation to the user registration form
```

Or fix existing issues:

```python
there's a bug where users can submit empty forms - fix it
```

Claude Code will:

- Locate the relevant code
- Understand the context
- Implement a solution
- Run tests if available


[​](#step-8-test-out-other-common-workflows)

Step 8: Test out other common workflows

There are a number of ways to work with Claude: **Refactor code**

```python
refactor the authentication module to use async/await instead of callbacks
```

**Write tests**

```python
write unit tests for the calculator functions
```

**Update documentation**

```python
update the README with installation instructions
```

**Code review**

```python
review my changes and suggest improvements
```

Talk to Claude like you would a helpful colleague. Describe what you want to achieve, and it will help you get there.


[​](#essential-commands)

Essential commands

Here are the most important commands for daily use:

| Command | What it does | Example |
|----|----|----|
| `claude` | Start interactive mode | `claude` |
| `claude "task"` | Run a one-time task | `claude "fix the build error"` |
| `claude -p "query"` | Run one-off query, then exit | `claude -p "explain this function"` |
| `claude -c` | Continue most recent conversation in current directory | `claude -c` |
| `claude -r` | Resume a previous conversation | `claude -r` |
| `/clear` | Clear conversation history | `/clear` |
| `/help` | Show available commands | `/help` |
| `exit` or Ctrl+D | Exit Claude Code | `exit` |

See the [CLI reference](/docs/en/cli-reference) for a complete list of commands.


[​](#pro-tips-for-beginners)

Pro tips for beginners

For more, see [best practices](/docs/en/best-practices) and [common workflows](/docs/en/common-workflows).

Be specific with your requests

Instead of: “fix the bug”Try: “fix the login bug where users see a blank screen after entering wrong credentials”

Use step-by-step instructions

Break complex tasks into steps:

```python
1. create a new database table for user profiles
2. create an API endpoint to get and update user profiles
3. build a webpage that allows users to see and edit their information
```

Let Claude explore first

Before making changes, let Claude understand your code:

```python
analyze the database schema
```

```python
build a dashboard showing products that are most frequently returned by our UK customers
```

Save time with shortcuts

- Press `?` to see all available keyboard shortcuts
- Use Tab for command completion
- Press ↑ for command history
- Type `/` to see all commands and skills


[​](#what’s-next)

What’s next?

Now that you’ve learned the basics, explore more advanced features:

## How Claude Code works

Understand the agentic loop, built-in tools, and how Claude Code interacts with your project

## Best practices

Get better results with effective prompting and project setup

## Common workflows

Step-by-step guides for common tasks

## Extend Claude Code

Customize with CLAUDE.md, skills, hooks, MCP, and more


[​](#getting-help)

Getting help

- **In Claude Code**: Type `/help` or ask “how do I…”
- **Documentation**: You’re here! Browse other guides
- **Community**: Join our [Discord](https://www.anthropic.com/discord) for tips and support


---
## quickstart-fc751d9be1.md

> ## Documentation Index
> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Quickstart

> Welcome to Claude Code!

export const InstallConfigurator = ({defaultSurface = 'terminal'}) => {
  const TERM = {
    mac: {
      label: 'macOS / Linux',
      cmd: 'curl -fsSL https://claude.ai/install.sh | bash'
    },
    win: {
      label: 'Windows'
    },
    brew: {
      label: 'Homebrew',
      cmd: 'brew install --cask claude-code'
    },
    winget: {
      label: 'WinGet',
      cmd: 'winget install Anthropic.ClaudeCode'
    }
  };
  const WIN_VARIANTS = {
    ps: 'irm https://claude.ai/install.ps1 | iex',
    cmd: 'curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd'
  };
  const TABS = [{
    key: 'terminal',
    label: 'Terminal'
  }, {
    key: 'desktop',
    label: 'Desktop'
  }, {
    key: 'vscode',
    label: 'VS Code'
  }, {
    key: 'jetbrains',
    label: 'JetBrains'
  }];
  const ALT_TARGETS = {
    desktop: {
      name: 'Desktop',
      tagline: 'The full agent in a native app for macOS and Windows.',
      installLabel: 'Download the app',
      installHref: 'https://claude.com/download?utm_source=claude_code&utm_medium=docs&utm_content=configurator_desktop_download',
      guideHref: '/en/desktop-quickstart'
    },
    vscode: {
      name: 'VS Code',
      tagline: 'Review diffs, manage context, and chat without leaving your editor.',
      installLabel: 'Install from Marketplace',
      installHref: 'https://marketplace.visualstudio.com/items?itemName=anthropic.claude-code',
      altCmd: 'code --install-extension anthropic.claude-code',
      guideHref: '/en/vs-code'
    },
    jetbrains: {
      name: 'JetBrains',
      tagline: 'Native plugin for IntelliJ, PyCharm, WebStorm, and other JetBrains IDEs.',
      installLabel: 'Install from Marketplace',
      installHref: 'https://plugins.jetbrains.com/plugin/27310-claude-code-beta-',
      guideHref: '/en/jetbrains'
    }
  };
  const PROVIDERS = [{
    key: 'anthropic',
    label: 'Anthropic'
  }, {
    key: 'bedrock',
    label: 'Amazon Bedrock'
  }, {
    key: 'foundry',
    label: 'Microsoft Foundry'
  }, {
    key: 'vertex',
    label: 'Google Vertex AI'
  }];
  const PROVIDER_NOTICE = {
    bedrock: <>
        <strong>Configure your AWS account first.</strong> Running on Bedrock
        requires model access enabled in the AWS console and IAM credentials.{' '}
        <a href="/en/amazon-bedrock">Bedrock setup guide →</a>
      </>,
    vertex: <>
        <strong>Configure your GCP project first.</strong> Running on Vertex AI
        requires the Vertex API enabled and a service account with the right
        permissions.{' '}
        <a href="/en/google-vertex-ai">Vertex setup guide →</a>
      </>,
    foundry: <>
        <strong>Configure your Azure resources first.</strong> Running on
        Microsoft Foundry requires an Azure subscription with a Foundry resource
        and model deployments provisioned.{' '}
        <a href="/en/microsoft-foundry">Foundry setup guide →</a>
      </>
  };
  const iconCheck = (size = 14) => <svg width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="3" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
      <polyline points="20 6 9 17 4 12" />
    </svg>;
  const iconCopy = (size = 14) => <svg width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
      <rect x="9" y="9" width="13" height="13" rx="2" />
      <path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
    </svg>;
  const iconArrowRight = (size = 13) => <svg width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
      <line x1="5" y1="12" x2="19" y2="12" />
      <polyline points="12 5 19 12 12 19" />
    </svg>;
  const iconArrowUpRight = (size = 14) => <svg width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
      <line x1="7" y1="17" x2="17" y2="7" />
      <polyline points="7 7 17 7 17 17" />
    </svg>;
  const iconInfo = (size = 16) => <svg width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
      <circle cx="12" cy="12" r="10" />
      <line x1="12" y1="16" x2="12" y2="12" />
      <line x1="12" y1="8" x2="12.01" y2="8" />
    </svg>;
  const [target, setTarget] = useState(defaultSurface);
  const [team, setTeam] = useState(false);
  const [provider, setProvider] = useState('anthropic');
  const [pkg, setPkg] = useState(() => (/Win/).test(navigator.userAgent) ? 'win' : 'mac');
  const [winCmd, setWinCmd] = useState(false);
  const [copied, setCopied] = useState(null);
  const copyTimer = useRef(null);
  const handleCopy = async (text, key) => {
    try {
      await navigator.clipboard.writeText(text);
    } catch {
      const ta = document.createElement('textarea');
      ta.value = text;
      document.body.appendChild(ta);
      ta.select();
      document.execCommand('copy');
      document.body.removeChild(ta);
    }
    clearTimeout(copyTimer.current);
    setCopied(key);
    copyTimer.current = setTimeout(() => setCopied(null), 1800);
  };
  const cardBodyCmd = (cmd, prompt) => {
    const on = copied === 'term';
    return <div className="cc-ic-card-body">
        <span className="cc-ic-prompt">{prompt || '$'}</span>
        <div className="cc-ic-cmd">{cmd}</div>
        <button type="button" className={'cc-ic-copy' + (on ? ' cc-ic-copied' : '')} onClick={() => handleCopy(cmd, 'term')}>
          {on ? iconCheck(13) : iconCopy(13)}
          <span>{on ? 'Copied' : 'Copy'}</span>
        </button>
      </div>;
  };
  const isWinInstaller = pkg === 'win';
  const isWinPrompt = pkg === 'win' || pkg === 'winget';
  const terminalCmd = isWinInstaller ? WIN_VARIANTS[winCmd ? 'cmd' : 'ps'] : TERM[pkg].cmd;
  const alt = ALT_TARGETS[target];
  const showNotice = team && provider !== 'anthropic';
  const STYLES = `
.cc-ic {
  --ic-slate: #141413;
  --ic-clay: #d97757;
  --ic-clay-deep: #c6613f;
  --ic-gray-000: #ffffff;
  --ic-gray-150: #f0eee6;
  --ic-gray-550: #73726c;
  --ic-gray-700: #3d3d3a;
  --ic-border-subtle: rgba(31, 30, 29, 0.08);
  --ic-border-default: rgba(31, 30, 29, 0.15);
  --ic-border-strong: rgba(31, 30, 29, 0.3);
  --ic-font-mono: ui-monospace, SFMono-Regular, Menlo, Monaco, 'Courier New', monospace;
  font-family: 'Anthropic Sans', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
  font-size: 14px; line-height: 1.5; color: var(--ic-slate);
  margin: 8px 0 32px;
}
.dark .cc-ic {
  --ic-slate: #f0eee6;
  --ic-gray-000: #262624;
  --ic-gray-150: #1f1e1d;
  --ic-gray-550: #91908a;
  --ic-gray-700: #bfbdb4;
  --ic-border-subtle: rgba(240, 238, 230, 0.08);
  --ic-border-default: rgba(240, 238, 230, 0.14);
  --ic-border-strong: rgba(240, 238, 230, 0.28);
}
.dark .cc-ic-check { background: transparent; }
.dark .cc-ic-card { border: 0.5px solid var(--ic-border-subtle); }
.dark .cc-ic-p-pill.cc-ic-active { box-shadow: 0 1px 2px rgba(0, 0, 0, 0.3); }
.cc-ic *, .cc-ic *::before, .cc-ic *::after { box-sizing: border-box; }
.cc-ic a { text-decoration: none; }
.cc-ic a:not([class]) { color: inherit; }
.cc-ic button { font-family: inherit; cursor: pointer; }

.cc-ic-tab-strip {
  display: inline-flex; gap: 2px;
  padding: 4px; background: var(--ic-gray-150);
  border-radius: 10px; overflow-x: auto;
  max-width: 100%;
}
.cc-ic-tab {
  appearance: none; background: none; border: none;
  padding: 10px 18px; font-size: 15px; font-weight: 430;
  color: var(--ic-gray-550); border-radius: 7px;
  white-space: nowrap;
  transition: color 0.12s, background-color 0.12s;
}
.cc-ic-tab:hover { color: var(--ic-gray-700); }
.cc-ic-tab.cc-ic-active {
  color: var(--ic-slate); font-weight: 500;
  background: var(--ic-gray-000);
  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.08);
}
.dark .cc-ic-tab.cc-ic-active { box-shadow: 0 1px 3px rgba(0, 0, 0, 0.4); }

.cc-ic-team-wrap { padding: 16px 0 20px; }
.cc-ic-team-toggle {
  display: flex; align-items: center; gap: 12px; font-family: inherit;
  padding: 12px 16px; font-size: 14px; font-weight: 430;
  color: var(--ic-gray-700); cursor: pointer; user-select: none;
  width: fit-content; background: var(--ic-gray-150);
  border: 0.5px solid var(--ic-border-subtle); border-radius: 8px;
  transition: border-color 0.15s;
}
.cc-ic-team-toggle:hover { border-color: var(--ic-border-default); }
.cc-ic-team-toggle.cc-ic-checked {
  background: rgba(217, 119, 87, 0.08);
  border-color: rgba(217, 119, 87, 0.25);
}
.cc-ic-check {
  width: 16px; height: 16px;
  border: 1px solid var(--ic-border-strong); border-radius: 4px;
  background: var(--ic-gray-000);
  display: flex; align-items: center; justify-content: center;
  flex-shrink: 0;
}
.cc-ic-check svg { color: #fff; display: none; }
.cc-ic-team-toggle.cc-ic-checked .cc-ic-check { background: var(--ic-clay-deep); border-color: var(--ic-clay-deep); }
.cc-ic-team-toggle.cc-ic-checked .cc-ic-check svg { display: block; }

.cc-ic-team-reveal { display: flex; flex-direction: column; gap: 12px; margin-bottom: 16px; }
.cc-ic-sales {
  display: flex; align-items: center; justify-content: space-between;
  gap: 16px; padding: 14px 16px;
  background: var(--ic-gray-000); border: 0.5px solid var(--ic-border-default);
  border-radius: 8px; flex-wrap: wrap;
}
.cc-ic-sales-text { font-size: 13px; color: var(--ic-gray-700); line-height: 1.5; flex: 1; min-width: 200px; }
.cc-ic-sales-text strong { font-weight: 550; color: var(--ic-slate); }
.cc-ic-sales-actions { display: flex; align-items: center; gap: 8px; flex-shrink: 0; }
.cc-ic-btn-clay {
  display: inline-flex; align-items: center; gap: 8px;
  background: var(--ic-clay-deep); color: #fff; border: none;
  border-radius: 8px; padding: 8px 14px;
  font-size: 13px; font-weight: 500;
  transition: background-color 0.15s; white-space: nowrap;
}
.cc-ic-btn-clay:hover { background: var(--ic-clay); }
.cc-ic-btn-ghost {
  display: inline-flex; align-items: center; gap: 8px;
  background: transparent; color: var(--ic-gray-700);
  border: 0.5px solid var(--ic-border-default);
  border-radius: 8px; padding: 8px 14px;
  font-size: 13px; font-weight: 500;
}
.cc-ic-btn-ghost:hover { background: rgba(0, 0, 0, 0.04); }

.cc-ic-provider-bar {
  display: flex; align-items: center; gap: 12px;
  padding: 14px 16px; background: var(--ic-gray-150);
  border-radius: 8px; font-size: 13px; flex-wrap: wrap;
}
.cc-ic-provider-bar .cc-ic-label { color: var(--ic-gray-550); flex-shrink: 0; }
.cc-ic-provider-pills { display: flex; gap: 4px; flex-wrap: wrap; }
.cc-ic-p-pill {
  appearance: none; border: none; background: transparent;
  padding: 6px 12px; border-radius: 6px;
  font-size: 13px; font-weight: 430; color: var(--ic-gray-700);
  white-space: nowrap;
}
.cc-ic-p-pill:hover { background: rgba(0, 0, 0, 0.04); }
.cc-ic-p-pill.cc-ic-active {
  background: var(--ic-gray-000); color: var(--ic-slate);
  font-weight: 500; box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
}
.cc-ic-provider-notice {
  display: flex; padding: 16px 18px;
  background: var(--ic-gray-000); border: 0.5px solid var(--ic-border-default);
  border-radius: 8px; gap: 14px; align-items: flex-start;
}
.cc-ic-provider-notice > svg { color: var(--ic-gray-550); margin-top: 2px; flex-shrink: 0; }
.cc-ic-provider-notice-body { font-size: 14px; line-height: 1.55; color: var(--ic-gray-700); }
.cc-ic-provider-notice-body strong { font-weight: 550; color: var(--ic-slate); }
.cc-ic-provider-notice-body a { color: var(--ic-clay-deep); font-weight: 500; }
.cc-ic-provider-notice-body a:hover { text-decoration: underline; }

.cc-ic-card { background: #141413; border-radius: 12px; overflow: hidden; }
.cc-ic-subtabs {
  display: flex; align-items: center;
  background: #1a1918;
  border-bottom: 0.5px solid rgba(255, 255, 255, 0.08);
  padding: 0 8px; overflow-x: auto;
}
.cc-ic-subtab {
  appearance: none; background: none; border: none;
  padding: 12px 16px; font-size: 12px;
  color: rgba(255, 255, 255, 0.5);
  position: relative; white-space: nowrap;
}
.cc-ic-subtab:hover { color: rgba(255, 255, 255, 0.75); }
.cc-ic-subtab.cc-ic-active { color: #fff; }
.cc-ic-subtab.cc-ic-active::after {
  content: ''; position: absolute;
  left: 12px; right: 12px; bottom: -0.5px;
  height: 2px; background: var(--ic-clay);
}
.cc-ic-shell-switch {
  display: inline-flex; gap: 2px;
  margin: 14px 26px 0; padding: 3px;
  background: rgba(255, 255, 255, 0.06);
  border: 0.5px solid rgba(255, 255, 255, 0.08);
  border-radius: 8px;
  font-family: inherit;
}
.cc-ic-shell-option {
  font: inherit; font-size: 12px; font-weight: 500;
  padding: 5px 12px; border-radius: 6px;
  background: transparent; border: none;
  color: rgba(255, 255, 255, 0.55);
  cursor: pointer; user-select: none; white-space: nowrap;
  transition: color 120ms ease, background-color 120ms ease;
}
.cc-ic-shell-option:hover { color: rgba(255, 255, 255, 0.85); }
.cc-ic-shell-option.cc-ic-active {
  background: rgba(255, 255, 255, 0.12);
  color: #fff;
  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.25);
}

.cc-ic-card-body { padding: 24px 26px; display: flex; align-items: flex-start; gap: 14px; }
.cc-ic-prompt {
  color: var(--ic-clay); font-family: var(--ic-font-mono);
  font-size: 17px; user-select: none; padding-top: 2px;
}
.cc-ic-cmd {
  flex: 1; font-family: var(--ic-font-mono);
  font-size: 17px; color: #f0eee6;
  line-height: 1.55; white-space: pre-wrap; word-break: break-word;
}
.cc-ic-copy {
  display: inline-flex; align-items: center; gap: 6px;
  background: rgba(255, 255, 255, 0.08);
  border: 0.5px solid rgba(255, 255, 255, 0.12);
  color: rgba(255, 255, 255, 0.85);
  padding: 7px 13px; border-radius: 8px;
  font-size: 13px; font-weight: 500; flex-shrink: 0;
}
.cc-ic-copy:hover { background: rgba(255, 255, 255, 0.14); }
.cc-ic-copy.cc-ic-copied { background: var(--ic-clay-deep); border-color: var(--ic-clay-deep); color: #fff; }

.cc-ic-below {
  margin-top: 12px; font-size: 13px; color: var(--ic-gray-550);
  display: flex; gap: 16px; flex-wrap: wrap; align-items: baseline;
}
.cc-ic-below a { color: var(--ic-gray-700); border-bottom: 0.5px solid var(--ic-border-default); }
.cc-ic-below a:hover { color: var(--ic-clay-deep); border-bottom-color: var(--ic-clay-deep); }
.cc-ic-handoff {
  padding: 22px 24px;
  background: linear-gradient(180deg, #faf9f4 0%, #f3f1e9 100%);
  border: 0.5px solid var(--ic-border-default);
  border-radius: 12px;
  box-shadow: 0 1px 2px rgba(31, 30, 29, 0.04), 0 6px 16px -4px rgba(31, 30, 29, 0.06);
}
.dark .cc-ic-handoff {
  background: linear-gradient(180deg, #262624 0%, #1f1e1d 100%);
  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.3), 0 6px 16px -4px rgba(0, 0, 0, 0.4);
}
.cc-ic-handoff-title {
  font-size: 16px; font-weight: 550; color: var(--ic-slate);
  letter-spacing: -0.01em; margin-bottom: 4px;
}
.cc-ic-handoff-sub {
  font-size: 14px; line-height: 1.5; color: var(--ic-gray-700);
  margin-bottom: 18px;
}
.cc-ic-handoff-actions { display: flex; gap: 10px; flex-wrap: wrap; }
.cc-ic-handoff-alt {
  margin-top: 12px; font-size: 12px; color: var(--ic-gray-550);
}
.cc-ic-handoff-alt code {
  font-family: var(--ic-font-mono); font-size: 11px;
  background: var(--ic-gray-150); padding: 2px 6px;
  border-radius: 4px; color: var(--ic-gray-700);
}
.cc-ic-copy-sm {
  appearance: none; border: none;
  display: inline-flex; align-items: center; justify-content: center;
  width: 22px; height: 22px;
  margin-left: 4px; vertical-align: middle;
  background: var(--ic-gray-150); color: var(--ic-gray-550);
  border-radius: 4px;
  transition: color 0.1s, background-color 0.1s;
}
.cc-ic-copy-sm:hover { color: var(--ic-gray-700); background: var(--ic-border-default); }
.cc-ic-copy-sm.cc-ic-copied { background: var(--ic-clay-deep); color: #fff; }

@media (max-width: 720px) {
  .cc-ic-tab { padding: 12px 14px; font-size: 14px; }
  .cc-ic-sales-actions { width: 100%; }
  .cc-ic-card-body { padding: 20px; }
  .cc-ic-cmd { font-size: 15px; }
}
`;
  return <div className="cc-ic not-prose">
      <style>{STYLES}</style>

      {}
      <div className="cc-ic-tab-strip" role="tablist">
        {TABS.map(t => <button key={t.key} type="button" role="tab" aria-selected={target === t.key} className={'cc-ic-tab' + (target === t.key ? ' cc-ic-active' : '')} onClick={() => setTarget(t.key)}>
            {t.label}
          </button>)}
      </div>

      {}
      <div className="cc-ic-team-wrap">
        <button type="button" role="switch" aria-checked={team} className={'cc-ic-team-toggle' + (team ? ' cc-ic-checked' : '')} onClick={() => setTeam(!team)}>
          <span className="cc-ic-check">{iconCheck(11)}</span>
          <span>
            I’m buying for a team or company (SSO, AWS/Azure/GCP, central billing)
          </span>
        </button>
      </div>

      {}
      {team && <div className="cc-ic-team-reveal">
          <div className="cc-ic-sales">
            <div className="cc-ic-sales-text">
              <strong>Set up your team:</strong> self-serve or talk to sales.
            </div>
            <div className="cc-ic-sales-actions">
              <a href="https://claude.ai/upgrade?initialPlanType=team&amp;utm_source=claude_code&amp;utm_medium=docs&amp;utm_content=configurator_team_get_started" className="cc-ic-btn-ghost">
                Get started
              </a>
              <a href="https://www.anthropic.com/contact-sales?utm_source=claude_code&amp;utm_medium=docs&amp;utm_content=configurator_team_contact_sales" className="cc-ic-btn-clay">
                Contact sales {iconArrowRight()}
              </a>
            </div>
          </div>

          <div className="cc-ic-provider-bar">
            <span className="cc-ic-label">Run on</span>
            <div className="cc-ic-provider-pills" role="radiogroup" aria-label="Provider">
              {PROVIDERS.map(p => <button key={p.key} type="button" role="radio" aria-checked={provider === p.key} className={'cc-ic-p-pill' + (provider === p.key ? ' cc-ic-active' : '')} onClick={() => setProvider(p.key)}>
                  {p.label}
                </button>)}
            </div>
          </div>

          {showNotice && <div className="cc-ic-provider-notice">
              {iconInfo()}
              <div className="cc-ic-provider-notice-body">
                {PROVIDER_NOTICE[provider]}
              </div>
            </div>}
        </div>}

      {}
      {target === 'terminal' && <div className="cc-ic-card">
          <div className="cc-ic-subtabs" role="tablist" aria-label="Install method">
            {Object.keys(TERM).map(k => <button key={k} type="button" role="tab" aria-selected={pkg === k} className={'cc-ic-subtab' + (pkg === k ? ' cc-ic-active' : '')} onClick={() => setPkg(k)}>
                {TERM[k].label}
              </button>)}
          </div>
          {isWinInstaller && <div className="cc-ic-shell-switch" role="tablist" aria-label="Shell">
              {[{
    k: 'ps',
    label: 'PowerShell'
  }, {
    k: 'cmd',
    label: 'CMD'
  }].map(({k, label}) => {
    const active = k === 'cmd' === winCmd;
    return <button key={k} type="button" role="tab" aria-selected={active} className={'cc-ic-shell-option' + (active ? ' cc-ic-active' : '')} onClick={() => setWinCmd(k === 'cmd')}>
                    {label}
                  </button>;
  })}
            </div>}
          {cardBodyCmd(terminalCmd, isWinPrompt ? '>' : '$')}
        </div>}

      {}
      {target === 'terminal' && <div className="cc-ic-below">
          {isWinInstaller && <span>
              Requires{' '}
              <a href="https://git-scm.com/downloads/win" target="_blank" rel="noopener">
                Git for Windows
              </a>.
            </span>}
          {(pkg === 'brew' || pkg === 'winget') && <span>
              Does not auto-update. Run{' '}
              <code>{pkg === 'brew' ? 'brew upgrade claude-code' : 'winget upgrade Anthropic.ClaudeCode'}</code>{' '}
              periodically.
            </span>}
          <a href="/en/troubleshooting">Troubleshooting</a>
        </div>}

      {alt && <div className="cc-ic-handoff">
          <div className="cc-ic-handoff-title">Claude Code for {alt.name}</div>
          <div className="cc-ic-handoff-sub">{alt.tagline}</div>
          <div className="cc-ic-handoff-actions">
            <a href={alt.installHref} className="cc-ic-btn-clay" {...alt.installHref.startsWith('http') ? {
    target: '_blank',
    rel: 'noopener'
  } : {}}>
              {alt.installLabel} {iconArrowUpRight(13)}
            </a>
            <a href={alt.guideHref} className="cc-ic-btn-ghost">
              {alt.name} guide {iconArrowRight(12)}
            </a>
          </div>
          {alt.altCmd && <div className="cc-ic-handoff-alt">
              or run <code>{alt.altCmd}</code>
              <button type="button" className={'cc-ic-copy-sm' + (copied === 'alt' ? ' cc-ic-copied' : '')} onClick={() => handleCopy(alt.altCmd, 'alt')} aria-label="Copy command">
                {copied === 'alt' ? iconCheck(11) : iconCopy(11)}
              </button>
            </div>}
        </div>}
    </div>;
};

This quickstart guide will have you using AI-powered coding assistance in a few minutes. By the end, you'll understand how to use Claude Code for common development tasks.

<div className="install-configurator-slot">
  <InstallConfigurator />
</div>

## Before you begin

Make sure you have:

* A terminal or command prompt open
  * If you've never used the terminal before, check out the [terminal guide](/en/terminal-guide)
* A code project to work with
* A [Claude subscription](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=quickstart_prereq) (Pro, Max, Team, or Enterprise), [Claude Console](https://console.anthropic.com/) account, or access through a [supported cloud provider](../02-Claude-Code-CLI/enterprise-deployment-overview-claude-code-docs-6eae0ecba2.md)

<Note>
  This guide covers the terminal CLI. Claude Code is also available on the [web](https://claude.ai/code), as a [desktop app](../16-Mobile-Desktop/desktop.md), in [VS Code](../03-IDE-Integrations/use-claude-code-in-vs-code-claude-code-docs-29143b6fee.md) and [JetBrains IDEs](../03-IDE-Integrations/jetbrains-4cf6bd8c22.md), in [Slack](../14-Connectors/claude-code-in-slack-claude-code-docs-c62a093e92.md), and in CI/CD with [GitHub Actions](../02-Claude-Code-CLI/claude-code-github-actions-claude-code-docs-0d633fbd8a.md) and [GitLab](../02-Claude-Code-CLI/claude-code-gitlab-ci-cd-claude-code-docs-fbcd915fee.md). See [all interfaces](/en/overview#use-claude-code-everywhere).
</Note>

## Step 1: Install Claude Code

To install Claude Code, use one of the following methods:

<Tabs>
  <Tab title="Native Install (Recommended)">
    **macOS, Linux, WSL:**

    ```bash theme={null}
    curl -fsSL https://claude.ai/install.sh | bash
    ```

    **Windows PowerShell:**

    ```powershell theme={null}
    irm https://claude.ai/install.ps1 | iex
    ```

    **Windows CMD:**

    ```batch theme={null}
    curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd
    ```

    If you see `The token '&&' is not a valid statement separator`, you're in PowerShell, not CMD. If you see `'irm' is not recognized as an internal or external command`, you're in CMD, not PowerShell. Your prompt shows `PS C:\` when you're in PowerShell and `C:\` without the `PS` when you're in CMD.

    **Native Windows setups require [Git for Windows](https://git-scm.com/downloads/win).** Install it first if you don't have it. WSL setups do not need it.

    <Info>
      Native installations automatically update in the background to keep you on the latest version.
    </Info>
  </Tab>

  <Tab title="Homebrew">
    ```bash theme={null}
    brew install --cask claude-code
    ```

    Homebrew offers two casks. `claude-code` tracks the stable release channel, which is typically about a week behind and skips releases with major regressions. `claude-code@latest` tracks the latest channel and receives new versions as soon as they ship.

    <Info>
      Homebrew installations do not auto-update. Run `brew upgrade claude-code` or `brew upgrade claude-code@latest`, depending on which cask you installed, to get the latest features and security fixes.
    </Info>
  </Tab>

  <Tab title="WinGet">
    ```powershell theme={null}
    winget install Anthropic.ClaudeCode
    ```

    <Info>
      WinGet installations do not auto-update. Run `winget upgrade Anthropic.ClaudeCode` periodically to get the latest features and security fixes.
    </Info>
  </Tab>
</Tabs>

You can also install with [apt, dnf, or apk](/en/setup#install-with-linux-package-managers) on Debian, Fedora, RHEL, and Alpine.

## Step 2: Log in to your account

Claude Code requires an account to use. When you start an interactive session with the `claude` command, you'll need to log in:

```bash theme={null}
claude
# You'll be prompted to log in on first use
```

```bash theme={null}
/login
# Follow the prompts to log in with your account
```

You can log in using any of these account types:

* [Claude Pro, Max, Team, or Enterprise](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=quickstart_login) (recommended)
* [Claude Console](https://console.anthropic.com/) (API access with pre-paid credits). On first login, a "Claude Code" workspace is automatically created in the Console for centralized cost tracking.
* [Amazon Bedrock, Google Vertex AI, or Microsoft Foundry](../02-Claude-Code-CLI/enterprise-deployment-overview-claude-code-docs-6eae0ecba2.md) (enterprise cloud providers)

Once logged in, your credentials are stored and you won't need to log in again. To switch accounts later, use the `/login` command.

## Step 3: Start your first session

Open your terminal in any project directory and start Claude Code:

```bash theme={null}
cd /path/to/your/project
claude
```

You'll see the Claude Code welcome screen with your session information, recent conversations, and latest updates. Type `/help` for available commands or `/resume` to continue a previous conversation.

<Tip>
  After logging in (Step 2), your credentials are stored on your system. Learn more in [Credential Management](/en/authentication#credential-management).
</Tip>

## Step 4: Ask your first question

Let's start with understanding your codebase. Try one of these commands:

```text theme={null}
what does this project do?
```

Claude will analyze your files and provide a summary. You can also ask more specific questions:

```text theme={null}
what technologies does this project use?
```

```text theme={null}
where is the main entry point?
```

```text theme={null}
explain the folder structure
```

You can also ask Claude about its own capabilities:

```text theme={null}
what can Claude Code do?
```

```text theme={null}
how do I create custom skills in Claude Code?
```

```text theme={null}
can Claude Code work with Docker?
```

<Note>
  Claude Code reads your project files as needed. You don't have to manually add context.
</Note>

## Step 5: Make your first code change

Now let's make Claude Code do some actual coding. Try a simple task:

```text theme={null}
add a hello world function to the main file
```

Claude Code will:

1. Find the appropriate file
2. Show you the proposed changes
3. Ask for your approval
4. Make the edit

<Note>
  Claude Code always asks for permission before modifying files. You can approve individual changes or enable "Accept all" mode for a session.
</Note>

## Step 6: Use Git with Claude Code

Claude Code makes Git operations conversational:

```text theme={null}
what files have I changed?
```

```text theme={null}
commit my changes with a descriptive message
```

You can also prompt for more complex Git operations:

```text theme={null}
create a new branch called feature/quickstart
```

```text theme={null}
show me the last 5 commits
```

```text theme={null}
help me resolve merge conflicts
```

## Step 7: Fix a bug or add a feature

Claude is proficient at debugging and feature implementation.

Describe what you want in natural language:

```text theme={null}
add input validation to the user registration form
```

Or fix existing issues:

```text theme={null}
there's a bug where users can submit empty forms - fix it
```

Claude Code will:

* Locate the relevant code
* Understand the context
* Implement a solution
* Run tests if available

## Step 8: Test out other common workflows

There are a number of ways to work with Claude:

**Refactor code**

```text theme={null}
refactor the authentication module to use async/await instead of callbacks
```

**Write tests**

```text theme={null}
write unit tests for the calculator functions
```

**Update documentation**

```text theme={null}
update the README with installation instructions
```

**Code review**

```text theme={null}
review my changes and suggest improvements
```

<Tip>
  Talk to Claude like you would a helpful colleague. Describe what you want to achieve, and it will help you get there.
</Tip>

## Essential commands

Here are the most important commands for daily use:

| Command             | What it does                                           | Example                             |
| ------------------- | ------------------------------------------------------ | ----------------------------------- |
| `claude`            | Start interactive mode                                 | `claude`                            |
| `claude "task"`     | Run a one-time task                                    | `claude "fix the build error"`      |
| `claude -p "query"` | Run one-off query, then exit                           | `claude -p "explain this function"` |
| `claude -c`         | Continue most recent conversation in current directory | `claude -c`                         |
| `claude -r`         | Resume a previous conversation                         | `claude -r`                         |
| `/clear`            | Clear conversation history                             | `/clear`                            |
| `/help`             | Show available commands                                | `/help`                             |
| `exit` or Ctrl+D    | Exit Claude Code                                       | `exit`                              |

See the [CLI reference](../02-Claude-Code-CLI/cli-reference-7bb98e3312.md) for a complete list of commands.

## Pro tips for beginners

For more, see [best practices](../10-Prompting-Guides/best-practices-for-claude-code-claude-code-docs-9686dc1633.md) and [common workflows](../02-Claude-Code-CLI/common-workflows-c909406123.md).

<AccordionGroup>
  <Accordion title="Be specific with your requests">
    Instead of: "fix the bug"

    Try: "fix the login bug where users see a blank screen after entering wrong credentials"
  </Accordion>

  <Accordion title="Use step-by-step instructions">
    Break complex tasks into steps:

    ```text theme={null}
    1. create a new database table for user profiles
    2. create an API endpoint to get and update user profiles
    3. build a webpage that allows users to see and edit their information
    ```
  </Accordion>

  <Accordion title="Let Claude explore first">
    Before making changes, let Claude understand your code:

    ```text theme={null}
    analyze the database schema
    ```

    ```text theme={null}
    build a dashboard showing products that are most frequently returned by our UK customers
    ```
  </Accordion>

  <Accordion title="Save time with shortcuts">
    * Press `?` to see all available keyboard shortcuts
    * Use Tab for command completion
    * Press ↑ for command history
    * Type `/` to see all commands and skills
  </Accordion>
</AccordionGroup>

## What's next?

Now that you've learned the basics, explore more advanced features:

<CardGroup cols={2}>
  <Card title="How Claude Code works" icon="microchip" href="/en/how-claude-code-works">
    Understand the agentic loop, built-in tools, and how Claude Code interacts with your project
  </Card>

  <Card title="Best practices" icon="star" href="/en/best-practices">
    Get better results with effective prompting and project setup
  </Card>

  <Card title="Common workflows" icon="graduation-cap" href="/en/common-workflows">
    Step-by-step guides for common tasks
  </Card>

  <Card title="Extend Claude Code" icon="puzzle-piece" href="/en/features-overview">
    Customize with CLAUDE.md, skills, hooks, MCP, and more
  </Card>
</CardGroup>

## Getting help

* **In Claude Code**: Type `/help` or ask "how do I..."
* **Documentation**: You're here! Browse other guides
* **Community**: Join our [Discord](https://www.anthropic.com/discord) for tips and support


---
## quickstart.md

> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Quickstart

> Welcome to Claude Code!

This quickstart guide will have you using AI-powered coding assistance in just a few minutes. By the end, you'll understand how to use Claude Code for common development tasks.

## Before you begin

Make sure you have:

* A terminal or command prompt open
* A code project to work with
* A [Claude subscription](https://claude.com/pricing) (Pro, Max, Teams, or Enterprise), [Claude Console](https://console.anthropic.com/) account, or access through a [supported cloud provider](../02-Claude-Code-CLI/enterprise-deployment-overview-claude-code-docs-6eae0ecba2.md)

<Note>
  This guide covers the terminal CLI. Claude Code is also available on the [web](https://claude.ai/code), as a [desktop app](../16-Mobile-Desktop/desktop.md), in [VS Code](../03-IDE-Integrations/use-claude-code-in-vs-code-claude-code-docs-29143b6fee.md) and [JetBrains IDEs](../03-IDE-Integrations/jetbrains-4cf6bd8c22.md), in [Slack](../02-Claude-Code-CLI/slack.md), and in CI/CD with [GitHub Actions](../02-Claude-Code-CLI/claude-code-github-actions-claude-code-docs-0d633fbd8a.md) and [GitLab](../02-Claude-Code-CLI/claude-code-gitlab-ci-cd-claude-code-docs-fbcd915fee.md). See [all interfaces](/en/overview#use-claude-code-everywhere).
</Note>

## Step 1: Install Claude Code

To install Claude Code, use one of the following methods:

<Tabs>
  <Tab title="Native Install (Recommended)">
    **macOS, Linux, WSL:**

    ```bash  theme={null}
    curl -fsSL https://claude.ai/install.sh | bash
    ```

    **Windows PowerShell:**

    ```powershell  theme={null}
    irm https://claude.ai/install.ps1 | iex
    ```

    **Windows CMD:**

    ```batch  theme={null}
    curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd
    ```

    <Info>
      Native installations automatically update in the background to keep you on the latest version.
    </Info>
  </Tab>

  <Tab title="Homebrew">
    ```sh  theme={null}
    brew install --cask claude-code
    ```

    <Info>
      Homebrew installations do not auto-update. Run `brew upgrade claude-code` periodically to get the latest features and security fixes.
    </Info>
  </Tab>

  <Tab title="WinGet">
    ```powershell  theme={null}
    winget install Anthropic.ClaudeCode
    ```

    <Info>
      WinGet installations do not auto-update. Run `winget upgrade Anthropic.ClaudeCode` periodically to get the latest features and security fixes.
    </Info>
  </Tab>
</Tabs>

## Step 2: Log in to your account

Claude Code requires an account to use. When you start an interactive session with the `claude` command, you'll need to log in:

```bash  theme={null}
claude
# You'll be prompted to log in on first use
```

```bash  theme={null}
/login
# Follow the prompts to log in with your account
```

You can log in using any of these account types:

* [Claude Pro, Max, Teams, or Enterprise](https://claude.com/pricing) (recommended)
* [Claude Console](https://console.anthropic.com/) (API access with pre-paid credits). On first login, a "Claude Code" workspace is automatically created in the Console for centralized cost tracking.
* [Amazon Bedrock, Google Vertex AI, or Microsoft Foundry](../02-Claude-Code-CLI/enterprise-deployment-overview-claude-code-docs-6eae0ecba2.md) (enterprise cloud providers)

Once logged in, your credentials are stored and you won't need to log in again. To switch accounts later, use the `/login` command.

## Step 3: Start your first session

Open your terminal in any project directory and start Claude Code:

```bash  theme={null}
cd /path/to/your/project
claude
```

You'll see the Claude Code welcome screen with your session information, recent conversations, and latest updates. Type `/help` for available commands or `/resume` to continue a previous conversation.

<Tip>
  After logging in (Step 2), your credentials are stored on your system. Learn more in [Credential Management](/en/iam#credential-management).
</Tip>

## Step 4: Ask your first question

Let's start with understanding your codebase. Try one of these commands:

```
what does this project do?
```

Claude will analyze your files and provide a summary. You can also ask more specific questions:

```
what technologies does this project use?
```

```
where is the main entry point?
```

```
explain the folder structure
```

You can also ask Claude about its own capabilities:

```
what can Claude Code do?
```

```
how do I create custom skills in Claude Code?
```

```
can Claude Code work with Docker?
```

<Note>
  Claude Code reads your files as needed - you don't have to manually add context. Claude also has access to its own documentation and can answer questions about its features and capabilities.
</Note>

## Step 5: Make your first code change

Now let's make Claude Code do some actual coding. Try a simple task:

```
add a hello world function to the main file
```

Claude Code will:

1. Find the appropriate file
2. Show you the proposed changes
3. Ask for your approval
4. Make the edit

<Note>
  Claude Code always asks for permission before modifying files. You can approve individual changes or enable "Accept all" mode for a session.
</Note>

## Step 6: Use Git with Claude Code

Claude Code makes Git operations conversational:

```
what files have I changed?
```

```
commit my changes with a descriptive message
```

You can also prompt for more complex Git operations:

```
create a new branch called feature/quickstart
```

```
show me the last 5 commits
```

```
help me resolve merge conflicts
```

## Step 7: Fix a bug or add a feature

Claude is proficient at debugging and feature implementation.

Describe what you want in natural language:

```
add input validation to the user registration form
```

Or fix existing issues:

```
there's a bug where users can submit empty forms - fix it
```

Claude Code will:

* Locate the relevant code
* Understand the context
* Implement a solution
* Run tests if available

## Step 8: Test out other common workflows

There are a number of ways to work with Claude:

**Refactor code**

```
refactor the authentication module to use async/await instead of callbacks
```

**Write tests**

```
write unit tests for the calculator functions
```

**Update documentation**

```
update the README with installation instructions
```

**Code review**

```
review my changes and suggest improvements
```

<Tip>
  **Remember**: Claude Code is your AI pair programmer. Talk to it like you would a helpful colleague - describe what you want to achieve, and it will help you get there.
</Tip>

## Essential commands

Here are the most important commands for daily use:

| Command             | What it does                                           | Example                             |
| ------------------- | ------------------------------------------------------ | ----------------------------------- |
| `claude`            | Start interactive mode                                 | `claude`                            |
| `claude "task"`     | Run a one-time task                                    | `claude "fix the build error"`      |
| `claude -p "query"` | Run one-off query, then exit                           | `claude -p "explain this function"` |
| `claude -c`         | Continue most recent conversation in current directory | `claude -c`                         |
| `claude -r`         | Resume a previous conversation                         | `claude -r`                         |
| `claude commit`     | Create a Git commit                                    | `claude commit`                     |
| `/clear`            | Clear conversation history                             | `/clear`                            |
| `/help`             | Show available commands                                | `/help`                             |
| `exit` or Ctrl+C    | Exit Claude Code                                       | `exit`                              |

See the [CLI reference](../02-Claude-Code-CLI/cli-reference-7bb98e3312.md) for a complete list of commands.

## Pro tips for beginners

For more, see [best practices](../10-Prompting-Guides/best-practices-for-claude-code-claude-code-docs-9686dc1633.md) and [common workflows](../02-Claude-Code-CLI/common-workflows-c909406123.md).

<AccordionGroup>
  <Accordion title="Be specific with your requests">
    Instead of: "fix the bug"

    Try: "fix the login bug where users see a blank screen after entering wrong credentials"
  </Accordion>

  <Accordion title="Use step-by-step instructions">
    Break complex tasks into steps:

    ```
    1. create a new database table for user profiles
    2. create an API endpoint to get and update user profiles
    3. build a webpage that allows users to see and edit their information
    ```
  </Accordion>

  <Accordion title="Let Claude explore first">
    Before making changes, let Claude understand your code:

    ```
    analyze the database schema
    ```

    ```
    build a dashboard showing products that are most frequently returned by our UK customers
    ```
  </Accordion>

  <Accordion title="Save time with shortcuts">
    * Press `?` to see all available keyboard shortcuts
    * Use Tab for command completion
    * Press ↑ for command history
    * Type `/` to see all commands and skills
  </Accordion>
</AccordionGroup>

## What's next?

Now that you've learned the basics, explore more advanced features:

<CardGroup cols={2}>
  <Card title="How Claude Code works" icon="microchip" href="/en/how-claude-code-works">
    Understand the agentic loop, built-in tools, and how Claude Code interacts with your project
  </Card>

  <Card title="Best practices" icon="star" href="/en/best-practices">
    Get better results with effective prompting and project setup
  </Card>

  <Card title="Common workflows" icon="graduation-cap" href="/en/common-workflows">
    Step-by-step guides for common tasks
  </Card>

  <Card title="Extend Claude Code" icon="puzzle-piece" href="/en/features-overview">
    Customize with CLAUDE.md, skills, hooks, MCP, and more
  </Card>
</CardGroup>

## Getting help

* **In Claude Code**: Type `/help` or ask "how do I..."
* **Documentation**: You're here! Browse other guides
* **Community**: Join our [Discord](https://www.anthropic.com/discord) for tips and support


---
## resources-tutorials-getting-started-with-claude-for-life-sciences.md

<!-- Source: https://claude.com/resources/tutorials/getting-started-with-claude-for-life-sciences -->

:root {
 --grid-breakout: [full-start] minmax(0, 1fr) [content-start] repeat(var(--_grid---column-count), minmax(0, var(--_grid---column-width))) [content-end] minmax(0, 1fr) [full-end];
 --grid-breakout-single: [full-start] minmax(0, 1fr) [content-start] minmax(0, calc(100% - var(--site--margin) * 2)) [content-end] minmax(0, 1fr) [full-end];
 }
 ::before, ::after {
 box-sizing: border-box;
 }
 .w-embed:before, .w-embed:after,
 .w-richtext:before, .w-richtext:after {
 content: unset;
 }
 html {
 background-color: var(--_theme---background);
 }
 button {
 background-color: unset;
 padding: unset;
 text-align: inherit;
 }
 button:not(:disabled) {
 cursor: pointer;
 }
 video {
 width: 100%;
 object-fit: cover;
 }
 /* remove padding of empty element */
 .wf-empty {
 padding: 0;
 }
 svg {
 max-width: 100%;
 }
 @media (prefers-color-scheme: light) {
 option { color: black; }
 }
 img::selection {
 background: transparent;
 }
 /* Typography */
 body {
 text-transform: var(--_text-style---text-transform);
 font-smoothing: antialiased;
 -webkit-font-smoothing: antialiased;
 }

 /* Clear Defaults */
 a:not ([class]) {
 text-decoration: underline;} 

 [class~="u-rich-text"] a,
 [class~="u-rich-text-cs"] a,
 [class~="u-rich-text-blog"] a,
 [class~="u-rich-text-tutorials"] a,
 a.u-rich-text,
 [class~="command_instruction"] a {
 transition: color .15s ease-out, text-decoration-color .15s ease-out;
 text-underline-offset: 3px;
 text-decoration: underline;
 color: currentcolor;
 text-decoration-color: var(--_theme---border-primary);
 }

 [class~="u-rich-text"] a:hover,
 [class~="u-rich-text-cs"] a:hover,
 [class~="u-rich-text-blog"] a:hover,
 [class~="u-rich-text-tutorials"] a:hover,
 a.u-rich-text:hover,
 [class~="command_instruction"] a:hover {
 text-decoration-color: var(--_theme---foreground-primary);
 color: var(--_theme---foreground-primary);
 }

 h1,h2,h3,h4,h5,h6,p,blockquote,label {
 font-family: inherit;
 font-size: inherit;
 font-weight: inherit;
 line-height: inherit;
 letter-spacing: inherit;
 text-transform: inherit;
 text-wrap: inherit;
 margin-top: 0;
 margin-bottom: 0;
 }
 select:has(option[value=""]:checked) {
 color: color-mix(in lab, currentcolor 60%, transparent)
 }
 /* Selection Color */
 ::selection {
 background-color: var(--_theme---selection--background);
 color: var(--_theme---selection--text);
 }
 /* Margin Trim */
 :is(.u-margin-trim,.u-rich-text) > :not(:not(.w-condition-invisible,.u-cover-absolute,.u-ignore-trim) ~ :not(.w-condition-invisible,.u-cover-absolute,.u-ignore-trim)),
 :is(.u-margin-trim,.u-rich-text) > :not(:not(.w-condition-invisible,.u-cover-absolute,.u-ignore-trim) ~ :not(.w-condition-invisible,.u-cover-absolute,.u-ignore-trim)).u-display-contents > :first-child {
 margin-top: 0;
 }
 :is(.u-margin-trim,.u-rich-text) > :not(:has(~ :not(.w-condition-invisible,.u-cover-absolute,.u-ignore-trim))),
 :is(.u-margin-trim,.u-rich-text) > :not(:has(~ :not(.w-condition-invisible,.u-cover-absolute,.u-ignore-trim))).u-display-contents > :last-child {
 margin-bottom: 0;
 }
 /* Line Height Trim */
 :is(h1,h2,h3,h4,h5,h6,p):not(.u-text-trim-off,:has([class*="u-text-style-"]))::before,
 [class*="u-text-style-"]:not(.u-text-trim-off,:has(h1,h2,h3,h4,h5,h6,p))::before {
 content: "";
 display: table;
 margin-bottom: calc(-0.5lh + var(--_text-style---trim-top));
 }
 :is(h1,h2,h3,h4,h5,h6,p):not(.u-text-trim-off,:has([class*="u-text-style-"]))::after,
 [class*="u-text-style-"]:not(.u-text-trim-off,:has(h1,h2,h3,h4,h5,h6,p))::after {
 content: "";
 display: table;
 margin-bottom: calc(-0.5lh + var(--_text-style---trim-bottom));
 }
 /* Rich Text Links */
 .w-richtext a {
 position: relative;
 z-index: 4;
 }
 /* Line Clamp */
 .u-line-clamp-1, .u-line-clamp-2, .u-line-clamp-3, .u-line-clamp-4 {
 -webkit-line-clamp: 1;
 -webkit-box-orient: vertical;
 }
 .u-line-clamp-2 { -webkit-line-clamp: 2; }
 .u-line-clamp-3 { -webkit-line-clamp: 3; }
 .u-line-clamp-4 { -webkit-line-clamp: 4; }
 /* Child Contain */
 .u-child-contain > * {
 width: 100%;
 max-width: inherit !important;
 margin-inline: 0 !important;
 margin-top: 0 !important;
 }
 /* Hide */
 .u-hide-if-empty:empty,
 .u-hide-if-empty:not(:has(> :not(.w-condition-invisible))),
 .u-hide-if-empty-cms:not(:has(.w-dyn-item)),
 .u-embed-js,
 .u-embed-css {
 display: none !important;
 }
 /* Focus State */
 a, button, :where([tabindex]), [data-outline] {
 outline-offset: var(--focus--offset-outer);
 }
 a:focus-visible,
 button:focus-visible,
 [tabindex]:focus-visible,
 label:has(input:focus-visible) [data-outline] {
 outline-color: color-mix(in srgb, var(--_button-style---border) 50%, transparent);
 outline-width: var(--focus--width);
 outline-style: solid;
 }

 /* Global / Clickable Component */
 .wf-design-mode .clickable_wrap {
 z-index: 0;
 }
 .clickable_wrap a[href="#"] {
 display: none;
 }
 .clickable_wrap a[href="#"] ~ button {
 display: block;
 }
 /* Responsive Above */
 @container threshold-large (width >= 62em) {
 .u-order-unset-above { order: unset !important; }
 .u-all-unset-above { all: unset !important; }
 .u-grid-below { display: flex !important; }
 .u-max-width-unset-above { max-width: unset !important; }
 .u-width-unset-above { width: unset !important; }
 .u-hide-above { display: none !important; }
 }
 @container threshold-medium (width >= 48em) {
 .u-order-unset-above { order: unset !important; }
 .u-all-unset-above { all: unset !important; }
 .u-grid-below { display: flex !important; }
 .u-max-width-unset-above { max-width: unset !important; }
 .u-width-unset-above { width: unset !important; }
 .u-hide-above { display: none !important; }
 }
 @container threshold-small (width >= 30em) {
 .u-order-unset-above { order: unset !important; }
 .u-all-unset-above { all: unset !important; }
 .u-grid-below { display: flex !important; }
 .u-max-width-unset-above { max-width: unset !important; }
 .u-width-unset-above { width: unset !important; }
 .u-hide-above { display: none !important; }
 }
 /* Responsive Below */
 @container threshold-large (width < 62em) {
 .u-order-unset-below { order: unset !important; }
 .u-all-unset-below { all: unset !important; }
 .u-grid-above { display: flex !important; }
 .u-max-width-unset-below { max-width: unset !important; }
 .u-width-unset-below { width: unset !important; }
 .u-alignment-unset-below {
 --_alignment---direction: start;
 align-self: start;
 }
 .u-hide-below { display: none !important; }
 }
 @container threshold-medium (width < 48em) {
 .u-order-unset-below { order: unset !important; }
 .u-all-unset-below { all: unset !important; }
 .u-grid-above { display: flex !important; }
 .u-max-width-unset-below { max-width: unset !important; }
 .u-width-unset-below { width: unset !important; }
 .u-alignment-unset-below {
 --_alignment---direction: start;
 align-self: start;
 }
 .u-hide-below { display: none !important; }
 }
 @container threshold-small (width < 30em) {
 .u-order-unset-below { order: unset !important; }
 .u-all-unset-below { all: unset !important; }
 .u-grid-above { display: flex !important; }
 .u-max-width-unset-below { max-width: unset !important; }
 .u-width-unset-below { width: unset !important; }
 .u-alignment-unset-below {
 --_alignment---direction: start;
 align-self: start;
 }
 .u-hide-below { display: none !important; }
 }
 /* Form Radio */
 .form_main_radio_label:has(input:checked) .form_main_radio_circle_inner {
 opacity: 1;
 }
 /* Form Checkbox */
 .form_main_checkbox_label:has(input:checked) .form_main_checkbox_box {
 background-color: currentColor;
 border-color: currentColor;
 }
 .form_main_checkbox_label:has(input:checked) .form_main_checkbox_icon {
 opacity: 1;
 }
 /* State Manager */
 [data-state] { --_state---true: 1; --_state---false: 0; }
 .is-active,
 [data-state~="checked"]:is(:checked, :has(:checked)),
 [data-state~="current"]:is(.w--current, :has(.w--current)),
 [data-state~="open"]:is(.w--open, :has(.w--open)),
 [data-state~="expanded"]:is([aria-expanded="true"], :has([aria-expanded="true"])),
 [data-state~="external"]:is([target="_blank"], :has([target="_blank"])) { 
 --_state---true: 0; --_state---false: 1;
 }
 .wf-design-mode [data-trigger~="preview"],
 [data-trigger~="focus"]:is(:focus-visible, :has(:focus-visible)),
 [data-trigger~="group"]:has([data-trigger~="focus-other"]:focus-visible, [data-trigger~="focus-other"] :focus-visible)
 [data-trigger~="focus-other"]:not(:focus-visible, :has(:focus-visible)) {
 --_trigger---on: 0; --_trigger---off: 1;
 }
 @media (hover: hover) {
 [data-button]:hover,
 [data-trigger~="hover"]:is(a:hover,button:hover,:has(a:hover,button:hover)),
 [data-trigger~="group"]:has([data-trigger~="hover-other"]:hover) [data-trigger~="hover-other"]:not(:hover) { 
 --_trigger---on: 0; --_trigger---off: 1;
 }
 [data-trigger~="hover-other"]:hover { --_trigger---on: 1 !important; --_trigger---off: 0 !important; }
 }
 @media (hover: none) {
 [data-trigger~="mobile"] { --_trigger---on: 0; --_trigger---off: 1; }
 }

 code, kbd, pre, samp {
 font-family: var(--_typography---font--mono-family);
 }
 body * {
 scrollbar-width: none; /* Firefox */
 -ms-overflow-style: none; /* IE/Edge Legacy */
 }
 body *::-webkit-scrollbar {
 display: none; /* Unreliable */
 width: 0px; /* WebKit/Blink */
 }

 @media (prefers-color-scheme: dark) {
 body,
 .u-theme-ivory,
 [data-wf--section--theme="ivory"] {
 --_theme---background-primary: var(--swatch--gray-950);
 --_theme---background-secondary: var(--swatch--gray-900);
 --_theme---background-tertiary: var(--swatch--gray-850);
 --_theme---border-primary: var(--swatch--gray-600);
 --_theme---border-secondary: var(--swatch--gray-700);
 --_theme---border-tertiary: var(--swatch--gray-750);
 --_theme---foreground-primary: var(--swatch--gray-050);
 --_theme---foreground-secondary: var(--swatch--gray-400);
 --_theme---foreground-tertiary: var(--swatch--gray-500);
 --_theme---pictogram-accent: var(--swatch--gray-750);
 --_theme---button-primary--background: var(--swatch--gray-050);
 --_theme---button-primary--text: var(--swatch--gray-950);
 --_theme---button-primary--border: var(--swatch--transparent);
 --_theme---button-primary--icon: var(--_theme---button-primary--text);
 --_theme---button-primary--background-hover: var(--_theme---button-primary--background);
 --_theme---button-primary--text-hover: var(--_theme---button-primary--text);
 --_theme---button-primary--border-hover: var(--_theme---button-primary--border);
 --_theme---button-primary--icon-hover: var(--_theme---background-primary);
 --_theme---button-secondary--background: var(--swatch--gray-750);
 --_theme---button-secondary--text: var(--swatch--gray-050);
 --_theme---button-secondary--border: var(--_theme---border-secondary);
 --_theme---button-secondary--icon: var(--_theme---button-secondary--text);
 --_theme---button-secondary--background-hover: var(--_theme---button-secondary--background);
 --_theme---button-secondary--text-hover: var(--_theme---button-secondary--text);
 --_theme---button-secondary--border-hover: var(--_theme---button-secondary--background);
 --_theme---button-secondary--icon-hover: var(--_theme---foreground-secondary);
 --_theme---button-tertiary--background: var(--_theme---background-primary);
 --_theme---button-tertiary--text: var(--swatch--gray-050);
 --_theme---button-tertiary--border: var(--_theme---border-secondary);
 --_theme---button-tertiary--icon: var(--_theme---button-tertiary--text);
 --_theme---button-tertiary--background-hover: var(--_theme---button-tertiary--background);
 --_theme---button-tertiary--text-hover: var(--_theme---button-tertiary--text);
 --_theme---button-tertiary--border-hover: var(--_theme---button-tertiary--border);
 --_theme---button-tertiary--icon-hover: var(--_theme---foreground-primary);
 --_theme---error-text: #df6666;
 --_theme---heroes-accent: #C46849;
 --_theme---white: var(--_theme---background-primary);
 }
 .u-theme-white,
 [data-wf--section--theme="white"] {
 --_theme---background-primary: var(--swatch--gray-850);
 --_theme---background-secondary: var(--swatch--gray-800);
 --_theme---background-tertiary: var(--swatch--gray-750);
 --_theme---border-primary: var(--swatch--gray-550);
 --_theme---border-secondary: var(--swatch--gray-650);
 --_theme---border-tertiary: var(--swatch--gray-700);
 --_theme---foreground-primary: var(--swatch--gray-050);
 --_theme---foreground-secondary: var(--swatch--gray-350);
 --_theme---foreground-tertiary: var(--swatch--gray-450);
 --_theme---pictogram-accent: var(--swatch--gray-700);
 --_theme---button-primary--background: var(--swatch--gray-050);
 --_theme---button-primary--text: var(--swatch--gray-950);
 --_theme---button-primary--border: var(--swatch--transparent);
 --_theme---button-primary--icon: var(--_theme---button-primary--text);
 --_theme---button-primary--background-hover: var(--_theme---button-primary--background);
 --_theme---button-primary--text-hover: var(--_theme---button-primary--text);
 --_theme---button-primary--border-hover: var(--_theme---button-primary--border);
 --_theme---button-primary--icon-hover: var(--_theme---background-primary);
 --_theme---button-secondary--background: var(--swatch--gray-700);
 --_theme---button-secondary--text: var(--swatch--gray-050);
 --_theme---button-secondary--border: var(--_theme---border-secondary);
 --_theme---button-secondary--icon: var(--_theme---button-secondary--text);
 --_theme---button-secondary--background-hover: var(--_theme---button-secondary--background);
 --_theme---button-secondary--text-hover: var(--_theme---button-secondary--text);
 --_theme---button-secondary--border-hover: var(--_theme---button-secondary--background);
 --_theme---button-secondary--icon-hover: var(--_theme---foreground-secondary);
 --_theme---button-tertiary--background: var(--_theme---background-primary);
 --_theme---button-tertiary--text: var(--swatch--gray-050);
 --_theme---button-tertiary--border: var(--_theme---border-secondary);
 --_theme---button-tertiary--icon: var(--_theme---button-tertiary--text);
 --_theme---button-tertiary--background-hover: var(--_theme---button-tertiary--background);
 --_theme---button-tertiary--text-hover: var(--_theme---button-tertiary--text);
 --_theme---button-tertiary--border-hover: var(--_theme---button-tertiary--border);
 --_theme---button-tertiary--icon-hover: var(--_theme---foreground-primary);
 --_theme---error-text: #df6666;
 --_theme---heroes-accent: #C46849;
 --_theme---white: var(--_theme---background-primary);
 }
 .u-theme-neutral-1,
 [data-wf--section--theme="neutral-1"] {
 --_theme---background-primary: var(--swatch--gray-800);
 --_theme---background-secondary: var(--swatch--gray-750);
 --_theme---background-tertiary: var(--swatch--gray-700);
 --_theme---border-primary: var(--swatch--gray-500);
 --_theme---border-secondary: var(--swatch--gray-600);
 --_theme---border-tertiary: var(--swatch--gray-650);
 --_theme---foreground-primary: var(--swatch--gray-050);
 --_theme---foreground-secondary: var(--swatch--gray-300);
 --_theme---foreground-tertiary: var(--swatch--gray-400);
 --_theme---pictogram-accent: var(--swatch--gray-650);
 --_theme---button-primary--background: var(--swatch--gray-050);
 --_theme---button-primary--text: var(--swatch--gray-950);
 --_theme---button-primary--border: var(--swatch--transparent);
 --_theme---button-primary--icon: var(--_theme---button-primary--text);
 --_theme---button-primary--background-hover: var(--_theme---button-primary--background);
 --_theme---button-primary--text-hover: var(--_theme---button-primary--text);
 --_theme---button-primary--border-hover: var(--_theme---button-primary--border);
 --_theme---button-primary--icon-hover: var(--_theme---background-primary);
 --_theme---button-secondary--background: var(--swatch--gray-650);
 --_theme---button-secondary--text: var(--swatch--gray-050);
 --_theme---button-secondary--border: var(--_theme---border-secondary);
 --_theme---button-secondary--icon: var(--_theme---button-secondary--text);
 --_theme---button-secondary--background-hover: var(--_theme---button-secondary--background);
 --_theme---button-secondary--text-hover: var(--_theme---button-secondary--text);
 --_theme---button-secondary--border-hover: var(--_theme---button-secondary--background);
 --_theme---button-secondary--icon-hover: var(--_theme---foreground-secondary);
 --_theme---button-tertiary--background: var(--_theme---background-primary);
 --_theme---button-tertiary--text: var(--swatch--gray-050);
 --_theme---button-tertiary--border: var(--_theme---border-secondary);
 --_theme---button-tertiary--icon: var(--_theme---button-tertiary--text);
 --_theme---button-tertiary--background-hover: var(--_theme---button-tertiary--background);
 --_theme---button-tertiary--text-hover: var(--_theme---button-tertiary--text);
 --_theme---button-tertiary--border-hover: var(--_theme---button-tertiary--border);
 --_theme---button-tertiary--icon-hover: var(--_theme---foreground-primary);
 --_theme---error-text: #df6666;
 --_theme---heroes-accent: #C46849;
 --_theme---white: var(--_theme---background-primary);
 }

 .logo_light {
 display: none;
 }
 .logo_dark {
 display: block;
 }
 .illustration_light {
 display: none;
 }
 .illustration_dark {
 display: block;
 }

 }

 @media (prefers-color-scheme: light) {
 .logo_light {
 display: block;
 }
 .logo_dark {
 display: none;
 }
 .illustration_light {
 display: block;
 }
 .illustration_dark {
 display: none;
 }
 }

 .u-text-font-mono {
 --_text-style---trim-top: var(--_typography---font--mono-text-trim-top);
 --_text-style---trim-bottom: var(--_typography---font--mono-text-trim-bottom);
 }

 .u-checklist ul {
 list-style: none;
 margin: 0;
 padding: 0;
 }

 .u-checklist ul li {
 position: relative; 
 padding-left: 2rem; 
 }

 .u-checklist ul li::before {
 content: ""; 
 position: absolute;
 left: 0;
 top: 0.1em;
 width: 1.5rem;
 height: 1.5rem;
 background-repeat: no-repeat;
 background-position: center;
 background-size: contain;
 background-image: url("data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20viewBox%3D%220%200%2024%2024%22%20fill%3D%22none%22%20xmlns%3D%22http%3A//www.w3.org/2000/svg%22%3E%3Cpath%20d%3D%22M18.226%206.13068C18.4439%205.95655%2018.7615%205.95361%2018.9842%206.13888C19.2067%206.32458%2019.2604%206.63728%2019.1283%206.88304L19.0604%206.98382L10.0602%2017.784C9.95233%2017.9133%209.7949%2017.9908%209.62665%2017.9984C9.45844%2018.0059%209.29454%2017.9429%209.17547%2017.8238L4.97541%2013.6237L4.89806%2013.53C4.7446%2013.2971%204.7705%2012.9802%204.97541%2012.7753C5.18032%2012.5704%205.49726%2012.5445%205.73011%2012.698L5.82386%2012.7753L9.55868%2016.5101L18.1393%206.21506L18.226%206.13068Z%22%20fill%3D%22%235E5D59%22/%3E%3C/svg%3E");
 }

 [class^="card_"][class$="_wrap"] .clickable_wrap.u-cover-absolute .clickable_link,
 [class^="card_"][class$="_wrap"] .clickable_wrap.u-cover-absolute .clickable_btn {
 outline-offset: var(--focus--offset-inner);
 }

 textarea[data-autogrow] {
 overflow-y: hidden;
 resize: none;
 height: 1.75rem; 
 min-height: 0; 
 }

 .btn_main_wrap::hover,
 .btn_small_wrap::hover,
 .btn_tiny_wrap::hover,
 .button_toggle_wrap::hover,
 .btn_icon_main_wrap::hover,
 .btn_icon_small_wrap::hover,
 .btn_icon_tiny_wrap::hover{
 transition: /* Transition to click/active */
 box-shadow ease-in-out 100ms, 
 background ease-in-out 100ms,
 color ease-in-out 50ms;
 }

 .btn_main_wrap::active,
 .btn_small_wrap::active,
 .btn_tiny_wrap::active,
 .button_toggle_wrap::active,
 .btn_icon_main_wrap::active,
 .btn_icon_small_wrap::active,
 .btn_icon_tiny_wrap::active{
 transition: /* Transition to click/active */
 box-shadow ease-in-out 50ms, 
 background ease-in-out 50ms,
 color ease-in-out 25ms;
 }

 .card_cs_grid_img img {
 max-width: 60%;
 max-height: 60%;
 }

 @container viewport (width < 30em) {
 [data-wf--grid--column-count="4"]:has(.card_feature_wrap) .c-grid {
 --_column-count---value: 1;
 }
 }
 @container viewport (min-width: 30em) and (max-width: 62em) {
 [data-wf--grid--column-count="4"]:has(.card_feature_wrap) .c-grid {
 --_column-count---value: 2;
 }
 }

 /* Mods for spacing and visibility of embed in accordian content used for schema */
 .accordion_content_text p:has(+ .w-embed.w-script) {
 margin-bottom: 0;
 }

 /* Absolute inner SVG of lottie to prevent page jump */
 .heroes_lottie_component svg {
 position: absolute;
 top: 0;
 left: 0;
 }

 /* Sticky scroll */
 @media screen and (min-width: 992px) {
 .sticky_image_link_wrap:has(.sticky_image_link.w--current) {
 opacity: 1;
 width: calc((100% - var(--_grid---gutter)) * (6 / 12));
 }
 }
 @media screen and (max-width: 767px) {
 .c-grid:last-child .sticky_image_block,
 .sticky_image_block:last-child {
 padding: 0;
 }
 .c-grid:last-child .sticky_image_wrap {
 margin-bottom: 0;
 }
 }

 #send, #threads, #get-help, #collaborate {
 display: block; /* or grid, flex - anything but contents */
 }

 /* Select text below clickable overlay */
 html.wf-design-mode .clickable_wrap {
 pointer-events: none;
 }

 document.addEventListener("DOMContentLoaded", function () {
 // ---------------- Config ----------------
 const EDGE_PADDING = 16; // >= 1rem from edges
 const OFFSET_Y = 10; // gap under trigger
 const DIM_OPACITY = 0.3;
 const DIM_EASE_MS = 350;
 const CLOSE_DELAY = 120;
 const isCoarse = () => matchMedia("(hover: none), (pointer: coarse)").matches;

 // ---------------- Bubble (single instance) ----------------
 function ensureBubble(){
 let el = document.querySelector(".tt-bubble");
 if (el) return el;
 el = document.createElement("div");
 el.className = "tt-bubble u-theme-white";
 el.setAttribute("role","tooltip");
 el.setAttribute("aria-hidden","true");
 el.style.left = "0px";
 el.style.top = "0px";
 el.innerHTML = `
 <div class="tt-inner">
 <div class="tt-h" id="tt-title"></div>
 <p class="tt-b" id="tt-body"></p>
 <button type="button" class="tt-close" aria-label="Close">×</button>
 </div>`;
 document.body.appendChild(el);
 return el;
 }
 const bubble = ensureBubble();
 const elH = bubble.querySelector("#tt-title");
 const elB = bubble.querySelector("#tt-body");
 const elClose = bubble.querySelector(".tt-close");

 // ---------------- Parse [[term|heading|body]] anywhere ----------------
 const TOKEN_RE = /\[\[([^|\]]+)\|([^|\]]+)\|([^\]]+)\]\]/g;
 const BLOCK_SKIP = new Set(["SCRIPT","STYLE","NOSCRIPT","TEXTAREA","INPUT","SELECT","CODE","PRE","TEMPLATE","IFRAME"]);
 function shouldSkipTextNode(n){
 let el = n.parentElement;
 while (el){
 if (BLOCK_SKIP.has(el.tagName) || el.isContentEditable) return true;
 el = el.parentElement;
 }
 return false;
 }
 const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT);
 const textNodes = [];
 while (walker.nextNode()){
 const n = walker.currentNode;
 if (!n.nodeValue || shouldSkipTextNode(n)) continue;
 if (TOKEN_RE.test(n.nodeValue)) textNodes.push(n);
 TOKEN_RE.lastIndex = 0;
 }
 textNodes.forEach(node => {
 const frag = document.createDocumentFragment();
 const insideLink = !!node.parentElement.closest("a");
 let text = node.nodeValue, last = 0; TOKEN_RE.lastIndex = 0; let m;
 while ((m = TOKEN_RE.exec(text))){
 if (m.index > last) frag.appendChild(document.createTextNode(text.slice(last, m.index)));
 const term=m[1].trim(), heading=m[2].trim(), body=m[3].trim();
 const t = insideLink ? document.createElement("span") : document.createElement("button");
 if (insideLink){ t.setAttribute("role","button"); t.setAttribute("tabindex","0"); } else { t.type="button"; }
 t.className="tt-trigger";
 t.textContent=term;
 t.setAttribute("data-tt-h", heading);
 t.setAttribute("data-tt-b", body);
 t.setAttribute("aria-haspopup","dialog");
 t.setAttribute("aria-expanded","false");
 frag.appendChild(t);
 last = TOKEN_RE.lastIndex;
 }
 if (last < text.length) frag.appendChild(document.createTextNode(text.slice(last)));
 node.parentNode.replaceChild(frag, node);
 });

 // ---------------- State ----------------
 let current = null;
 let hoverCount = 0;
 let closeTimer = null;

 // Dimming bookkeeping
 let dimCtx = null; // { container, dimEls:[], wrappedTexts:[], pathEls:[] }

 // ---------------- Find the correct "text element" container ----------------
 function findTextContainer(trigger){
 // Prefer common RTE wrappers
 let el = trigger.closest(".w-richtext, .rich-text, .rte, [data-rte]");
 if (el) return el;

 // Otherwise climb until we find an ancestor that contains multiple block nodes anywhere inside.
 const BLOCK_SEL = "p,h1,h2,h3,h4,h5,h6,ul,ol,li,blockquote,pre,figure,figcaption";
 el = trigger.parentElement;
 while (el && el !== document.body){
 const blockCount = el.querySelectorAll(BLOCK_SEL).length;
 if (blockCount >= 2) return el;
 el = el.parentElement;
 }

 // Fallback: nearest non-inline container
 el = trigger.parentElement || document.body;
 while (el && el !== document.body){
 const d = getComputedStyle(el).display;
 if (d !== "inline" && d !== "contents") return el;
 el = el.parentElement;
 }
 return document.body;
 }

 // Utility: child of `ancestor` that contains `target` (direct child)
 function directChildContaining(ancestor, target){
 for (const ch of ancestor.children){
 if (ch === target || ch.contains(target)) return ch;
 }
 return null;
 }

 function getElementTarget(e) {
 // If target is already an Element, use it
 if (e.target instanceof Element) return e.target;
 // Otherwise, walk the composed/path for the first Element
 const path = (typeof e.composedPath === 'function') ? e.composedPath() : [];
 for (const n of path) if (n instanceof Element) return n;
 return null;
 }

 // ---------------- Dim everything except the trigger branch (sibling branches only) ----------------
 function dimAllOtherBranches(container, trigger){
 undim(); // clear previous

 const dimEls = [];
 const wrappedTexts = [];
 const pathEls = [];

 // Build ELEMENT-only path [container -> ... -> trigger]
 const path = [];
 for (let el = trigger; el && el !== container; el = el.parentElement) path.push(el);
 path.push(container);
 path.reverse();

 // At each ancestor level, find the *direct* child that leads to the trigger
 for (let i = 0; i < path.length; i++){
 const anc = path[i];
 const branchChild = (i < path.length - 1) ? directChildContaining(anc, path[i+1]) : path[i]; // last step is the trigger itself

 // Fade element siblings (whole branches)
 for (const child of anc.children){
 if (child === branchChild) continue; // keep the path branch crisp
 // Never fade any element that is (or contains) the trigger
 if (child === trigger || child.contains(trigger)) continue;
 child.style.transition = `opacity ${DIM_EASE_MS}ms ease`;
 child.style.opacity = String(DIM_OPACITY);
 dimEls.push(child);
 }

 // Fade TEXT NODE siblings directly under this ancestor (outside branchChild)
 anc.childNodes.forEach(node => {
 if (node.nodeType !== 3) return; // text only
 if (!node.nodeValue || !node.nodeValue.trim()) return;
 // If this text node sits inside branchChild, skip
 if (branchChild && branchChild.contains && branchChild.contains(node)) return;
 const span = document.createElement("span");
 span.style.transition = `opacity ${DIM_EASE_MS}ms ease`;
 span.style.opacity = String(DIM_OPACITY);
 span.textContent = node.nodeValue;
 node.parentNode.replaceChild(span, node);
 wrappedTexts.push(span);
 });

 // Keep a reference to the path elements (so we can explicitly restore opacity if needed)
 if (anc && anc.nodeType === 1) pathEls.push(anc);
 }

 // Hard-guard: explicitly set opacity:1 on the entire path to neutralize any inherited fade
 pathEls.forEach(el => {
 el.style.opacity = "1";
 });

 dimCtx = { container, dimEls, wrappedTexts, pathEls };
 }

 function undim(){
 if (!dimCtx) return;
 const { dimEls, wrappedTexts, pathEls } = dimCtx;

 // Animate back
 dimEls.forEach(el => {
 el.style.transition = `opacity ${DIM_EASE_MS}ms ease`;
 el.style.opacity = "1";
 // remove inline style after the animation so we don't override site CSS
 setTimeout(() => { if (el) el.style.opacity = ""; }, DIM_EASE_MS + 50);
 });

 wrappedTexts.forEach(span => {
 span.style.transition = `opacity ${DIM_EASE_MS}ms ease`;
 span.style.opacity = "1";
 span.addEventListener("transitionend", () => {
 if (!span.parentNode) return;
 span.parentNode.replaceChild(document.createTextNode(span.textContent || ""), span);
 }, { once:true });
 });

 // Clear hard-guard on path
 pathEls.forEach(el => { if (el) el.style.opacity = ""; });

 dimCtx = null;
 }

 // ---------------- Positioning (centered, edge-aware, flip) ----------------
 function clamp(v,min,max){ return Math.max(min,Math.min(max,v)); }
 function measureBubbleForPlacement(){
 const wasOpen = bubble.classList.contains("is-open");
 if (!wasOpen){ bubble.style.visibility="hidden"; bubble.classList.add("is-open"); }
 const rect = bubble.getBoundingClientRect();
 if (!wasOpen){ bubble.classList.remove("is-open"); bubble.style.visibility=""; }
 return { w: rect.width, h: rect.height };
 }
 function placeAnchored(trigger){
 const vw=innerWidth, vh=innerHeight;
 const r = trigger.getBoundingClientRect();
 const { w, h } = measureBubbleForPlacement();

 let left = r.left + (r.width/2) - (w/2);
 left = clamp(left, EDGE_PADDING, Math.max(EDGE_PADDING, vw - EDGE_PADDING - w));

 const topBelow = r.bottom + OFFSET_Y;
 const spaceBelow = vh - topBelow - EDGE_PADDING;
 const placeBelow = spaceBelow >= h;
 let top = placeBelow ? topBelow : (r.top - h - OFFSET_Y);
 top = clamp(top, EDGE_PADDING, Math.max(EDGE_PADDING, vh - EDGE_PADDING - h));

 bubble.style.left = left + "px";
 bubble.style.top = top + "px";

 const br = bubble.getBoundingClientRect();
 if (br.bottom > vh - EDGE_PADDING){
 bubble.style.maxHeight = (vh - 2*EDGE_PADDING) + "px";
 bubble.style.overflowY = "auto";
 } else {
 bubble.style.maxHeight = "none";
 bubble.style.overflowY = "visible";
 }
 }

 // ---------------- Open / Close (place → fade/scale) ----------------
 function animateIn(){
 bubble.style.transition = "none";
 bubble.style.opacity = "0";
 bubble.style.transform = "scale(0.95)";
 void bubble.offsetWidth;
 bubble.style.transition = "opacity .18s ease, transform .18s ease";
 bubble.style.opacity = "1";
 bubble.style.transform = "scale(1)";
 }
 function animateOut(done){
 bubble.style.transition = "opacity .16s ease, transform .16s ease";
 bubble.style.opacity = "0";
 bubble.style.transform = "scale(0.95)";
 const end = () => { bubble.removeEventListener("transitionend", end); done && done(); };
 bubble.addEventListener("transitionend", end);
 setTimeout(end, 260);
 }

 function openFromTrigger(trigger){
 if (current && current !== trigger) forceClose();
 current = trigger;
 trigger.setAttribute("aria-expanded","true");

 elH.textContent = trigger.getAttribute("data-tt-h") || "";
 elB.textContent = trigger.getAttribute("data-tt-b") || "";

 bubble.classList.add("is-open");
 bubble.setAttribute("aria-hidden","false");

 placeAnchored(trigger);
 animateIn();

 const container = findTextContainer(trigger);
 dimAllOtherBranches(container, trigger);

 hoverCount = 0;
 cancelCloseTimer();
 }

 function forceClose(){
 if (!current) return;
 bubble.classList.remove("is-open");
 bubble.setAttribute("aria-hidden","true");
 current.setAttribute("aria-expanded","false");
 current = null;
 undim();
 hoverCount = 0;
 cancelCloseTimer();
 }

 function closeWithAnim(){
 if (!current) return;
 const t = current;
 animateOut(() => {
 bubble.classList.remove("is-open");
 bubble.setAttribute("aria-hidden","true");
 t.setAttribute("aria-expanded","false");
 current = null;
 undim();
 });
 }

 function scheduleClose(){
 cancelCloseTimer();
 closeTimer = setTimeout(() => {
 if (hoverCount <= 0 && !isCoarse()) closeWithAnim();
 }, CLOSE_DELAY);
 }
 function cancelCloseTimer(){ if (closeTimer){ clearTimeout(closeTimer); closeTimer = null; } }

 // ---------------- Hover-intent (desktop) ----------------
 function onZoneEnter(){ if (isCoarse()) return; hoverCount++; cancelCloseTimer(); }
 function onZoneLeave(){ if (isCoarse()) return; hoverCount = Math.max(0, hoverCount - 1); if (hoverCount === 0) scheduleClose(); }

 bubble.addEventListener("pointerenter", onZoneEnter, true);
 bubble.addEventListener("mouseenter", onZoneEnter, true);
 bubble.addEventListener("pointerleave", onZoneLeave, true);
 bubble.addEventListener("mouseleave", onZoneLeave, true);

 const handleEnter = (e) => {
 if (isCoarse()) return;
 const target = getElementTarget(e);
 if (!target) return;
 const t = target.closest(".tt-trigger");
 if (!t) return;
 onZoneEnter();
 if (!current || current !== t) openFromTrigger(t);
 };
 const handleLeave = (e) => {
 if (isCoarse()) return;
 const target = getElementTarget(e);
 if (!target) return;
 const t = target.closest(".tt-trigger");
 if (!t) return;
 onZoneLeave();
 };
 document.addEventListener("pointerenter", handleEnter, true);
 document.addEventListener("mouseenter", handleEnter, true);
 document.addEventListener("pointerleave", handleLeave, true);
 document.addEventListener("mouseleave", handleLeave, true);

 // ---------------- Keyboard ----------------
 document.addEventListener("focusin", (e) => {
 if (!e.target) return;
 const t = e.target.closest(".tt-trigger");
 if (t) openFromTrigger(t);
 });
 document.addEventListener("focusout", (e) => {
 if (!e.target) return;
 const t = e.target.closest(".tt-trigger");
 if (t && current === t) closeWithAnim();
 });

 // ---------------- Mobile / coarse ----------------
 document.addEventListener("pointerdown", (e) => {
 if (!isCoarse()) return;

 const t = e.target.closest(".tt-trigger");
 if (!t) return;
 e.preventDefault();
 e.stopPropagation();
 if (current === t && bubble.classList.contains("is-open")) { closeWithAnim(); return; }
 openFromTrigger(t);
 }, true);

 document.addEventListener("click", (e) => {
 if (!isCoarse()) return;
 if (!bubble.classList.contains("is-open")) return;
 const inBubble = !!e.target.closest(".tt-bubble");
 const onTrigger = !!e.target.closest(".tt-trigger");
 if (!inBubble && !onTrigger) closeWithAnim();
 }, true);

 // Close button + ESC
 elClose.addEventListener("click", closeWithAnim);
 document.addEventListener("keydown", (e) => { if (e.key === "Escape") closeWithAnim(); });

 // Reposition on resize/scroll while open
 const reposition = () => { if (!current) return; placeAnchored(current); };
 addEventListener("resize", reposition, { passive: true });
 addEventListener("scroll", reposition, { passive: true });
 });
 
/* Tooltip Styles */

 /* Trigger */
 .tt-trigger {
 cursor: help;
 text-decoration: underline dotted;
 text-underline-offset: .2em;
 color: inherit;
 }
 .tt-trigger:focus-visible{ outline:2px solid currentColor; outline-offset:2px; }

 /* Bubble */
 .tt-bubble{
 position: fixed;
 z-index: 10;
 max-width: 17rem;
 background: var(--_theme---background-primary);
 box-shadow: 0 4px 24px rgba(0,0,0,.05);
 border-radius: var(--radius--large);
 border-style: solid;
 border-color: var(--_theme---border-tertiary);
 padding: var(--_spacing---space--1-5rem);
 pointer-events: none;
 opacity: 0;
 transform: translate3d(0,0,0) scale(.98);
 transition: opacity .3s ease, transform .3s ease;
 will-change: transform, opacity;
 }
 .tt-bubble.is-open{ opacity:1; transform:translate3d(0,0,0) scale(1); pointer-events:auto; }

 .tt-h{ 
 margin-bottom: var(--_spacing---space--0-5rem); 
 font-size: var(--_typography---font-size--body-3); 
 font-family: var(--_typography---font--secondary-family);
 line-height: var(--_typography---line-height--1-6); 
 color: var(--_theme---foreground-primary);
 }
 .tt-b{ 
 margin:0; 
 font-size: var(--_typography---font-size--caption);
 line-height: var(--_typography---line-height--1-6);
 color: var(--_theme---foreground-tertiary);
 }

 /* Mobile close button */
 .tt-close {
 display: none;
 }
 @media (hover: none), (pointer: coarse) {
 .tt-close {
 display: inline-flex;
 position: absolute;
 top: 0.5rem;
 right: 0.5rem;
 width: 32px;
 height: 32px;
 align-items: center;
 justify-content: center;
 border: 0;
 border-radius: 999px;
 background: transparent;
 font-size: 22px; 
 line-height: 1;
 color: inherit;
 cursor: pointer;
 touch-action: manipulation;
 }
 .tt-close:focus-visible { outline: 2px solid currentColor; outline-offset: 2px; }
 .tt-close:hover { opacity: 1; }
 }

 html[lang="de-DE"] h1, html[lang="de-DE"] h2, html[lang="de-DE"] h3, 
 html[lang="de-DE"] h4, html[lang="de-DE"] h5, html[lang="de-DE"] h6,
 html[lang="de-DE"] p, html[lang="de-DE"] li,
 html[lang="fr-FR"] h1, html[lang="fr-FR"] h2, html[lang="fr-FR"] h3,
 html[lang="fr-FR"] h4, html[lang="fr-FR"] h5, html[lang="fr-FR"] h6,
 html[lang="fr-FR"] p, html[lang="fr-FR"] li {
 overflow-wrap: break-word;
 hyphens: auto;
 }

 :root {
 --nav--icon-thickness: var(--border-width--main);
 --nav--hamburger-thickness: var(--nav--icon-thickness);
 --nav--hamburger-gap: var(--_spacing---space--0-25rem);
 --nav--hamburger-rotate: 45;
 --nav--dropdown-duration: 300ms;
 --nav--dropdown-open-duration: 600ms;
 --nav--dropdown-delay: 0ms;
 --ease-expo-out: cubic-bezier(0.16, 1, 0.3, 1);
 }

 /* ========== GENERAL RESPONSIVE RULES ========== */

 /* Lock body when nav is open (script toggles .is-nav-open) */
 @media (width < 56em) {
 body.is-nav-open { overflow: hidden; }
 }

 @container (min-width: 56em) {
 .nav_wrap.is-desktop { display: block; }
 .nav_wrap.is-mobile { display: none; }
 }
 @container (width < 28em) {
 .nav_mobile_layout .nav_actions_mobile { display: none; }
 }

 /* ========== DROPDOWN STYLING ========== */

 html:not(.wf-design-mode) .nav_dropdown_component > .w-dropdown-list {
 display: grid !important;
 grid-template-columns: minmax(0, 1fr);
 grid-template-rows: 0fr;
 transition:
 grid-template-rows var(--nav--dropdown-duration) var(--ease-expo-out),
 visibility 0s var(--nav--dropdown-duration),
 opacity var(--nav--dropdown-duration) var(--ease-expo-out);
 visibility: hidden;
 opacity: 0;
 }
 html:not(.wf-design-mode) .nav_dropdown_component > .w-dropdown-list.w--open {
 visibility: visible;
 opacity: 1;
 transition:
 grid-template-rows var(--nav--dropdown-duration) var(--ease-expo-out),
 visibility 0s 0s,
 opacity var(--nav--dropdown-duration) var(--ease-expo-out);
 }
 .nav_dropdown_component > .w-dropdown-list > * { overflow: hidden; }
 .nav_dropdown_component:has(> .w-dropdown-toggle[aria-expanded="true"]) > .w-dropdown-list {
 --nav--dropdown-duration: var(--nav--dropdown-open-duration);
 grid-template-rows: 1fr;
 }
 /*.nav_wrap.is-desktop:has(.nav_dropdown_component > .w-dropdown-toggle.w--open[aria-expanded="false"])
 .nav_dropdown_component:has(> .w--open[aria-expanded="true"]) > .w-dropdown-list {
 transition-delay: var(--nav--dropdown-duration);
 }*/

 /* Dropdown caret rotation */
 .nav_links_svg.is-desktop { transition: transform 750ms var(--ease-expo-out); }
 .w-dropdown-toggle[aria-expanded="true"] .nav_links_svg.is-desktop { transform: rotate(-180deg); }

 .nav_links_svg_line.is-2 { transition: transform 500ms var(--ease-expo-out); }
 .w-dropdown-toggle[aria-expanded="true"] .nav_links_svg_line.is-2 { transform: rotate(0deg); }

 /* open (replicates your original transforms) */
 .nav_btn_wrap[aria-expanded="true"] .nav_btn_line:nth-child(1),
 .nav_btn_wrap[aria-expanded="true"] > * > :first-child {
 transform:
 translateY(calc(var(--nav--hamburger-thickness) * 1 + var(--nav--hamburger-gap) * 1))
 rotate(calc(var(--nav--hamburger-rotate) * -1deg));
 }
 .nav_btn_wrap[aria-expanded="true"] .nav_btn_line:nth-child(2),
 .nav_btn_wrap[aria-expanded="true"] > * > :nth-child(2) {
 opacity: 0;
 }
 .nav_btn_wrap[aria-expanded="true"] .nav_btn_line:nth-child(3),
 .nav_btn_wrap[aria-expanded="true"] > * > :last-child {
 transform:
 translateY(calc(var(--nav--hamburger-thickness) * -1 + var(--nav--hamburger-gap) * -1))
 rotate(calc(var(--nav--hamburger-rotate) * 1deg));
 width: 1rem;
 }

 /* ========== HOVER & THEME EFFECTS ========== */
 @media (hover: hover) and (pointer: fine) {
 body:has(.nav_dropdown_item:hover) .nav_dropdown_item:not(:hover) > * > * {
 color: var(--_theme---foreground-tertiary);
 }
 .nav_dropdown_link {
 transition:
 background-color 300ms ease,
 color 300ms ease;
 }
 .nav_dropdown_item:hover .nav_dropdown_link {
 background: var(--_theme---background-tertiary);
 color: var(--_theme---foreground-primary);
 }
 .nav_secondary_wrap .nav_dropdown_item:hover .nav_dropdown_link {
 background: var(--_theme---background-tertiary);
 color: var(--_theme---foreground-primary);
 }
 .nav_wrap.is-mobile .nav_dropdown_item:hover .nav_dropdown_link {
 color: var(--_theme---foreground-primary);
 }
 .nav_links_text { transition: color 500ms var(--ease-expo-out); }
 .nav_links_svg {
 transition:
 transform 500ms var(--ease-expo-out),
 color 500ms var(--ease-expo-out);
 }
 .nav_links_item:hover .nav_links_text,
 .nav_links_item:hover .nav_links_svg { color: var(--_theme---foreground-primary); }
 }

 /* ========== LAYOUT / UTILITY (kept, de-Webflow’d) ========== */
 .nav_wrap.is-mobile [data-open-on-mobile] > .w-dropdown-toggle { display: none; }
 .nav_wrap.is-mobile [data-open-on-mobile] > .w-dropdown-list {
 visibility: visible;
 opacity: 1;
 display: block;
 grid-template-rows: 1fr;
 }
 .nav_buttons_item .button_main_wrap { width: 100%; min-width: max-content; }

 /* Optional: fade out mobile actions while open */
 .nav_actions_wrap { transition: opacity 500ms var(--ease-expo-out); }
 body.is-nav-open .nav_actions_mobile .nav_actions_wrap {
 opacity: 0;
 pointer-events: none;
 }

 .nav_links_item:first-child {
 border-top: none;
 }

 /* ========== Breadcrumbs ========== */
 .breadcrumb_text.is_linked[href="#"],
 .breadcrumb_text:has(+.breadcrumb_text.is_linked:not([href="#"])) {
 display: none;
 }
 .breadcrumb_text.is_linked:not([href="#"]) {
 display: block;
 }

document.addEventListener("DOMContentLoaded", function () {
 document.querySelectorAll(".nav_component").forEach((root) => {
 if (root.dataset.scriptInitialized) return;
 root.dataset.scriptInitialized = "true";

 if (!window.gsap) { console.error("GSAP not found"); return; }

 const btn = root.querySelector('.nav_btn_wrap');
 const menu = root.querySelector('.nav_menu_wrap');
 if (!btn || !menu) { console.warn('Missing .nav_btn_wrap or .nav_menu_wrap in', root); return; }

 // a11y setup (scoped)
 if (!btn.hasAttribute('type')) btn.setAttribute('type', 'button');
 if (!btn.hasAttribute('aria-expanded')) btn.setAttribute('aria-expanded', 'false');
 if (!menu.id) menu.id = 'primary-nav-' + Math.random().toString(36).slice(2);
 if (!btn.hasAttribute('aria-controls')) btn.setAttribute('aria-controls', menu.id);
 menu.setAttribute('aria-hidden', 'true');

 // targets (scoped)
 const items = Array.from(menu.querySelectorAll('.nav_links_item'));
 const actions = menu.querySelector('.nav_menu_actions_wrap');

 // feature detection
 const prefersReduced = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
 const canClipInset = !!(window.CSS && CSS.supports && (
 CSS.supports('clip-path','inset(0 0 100% 0)') || CSS.supports('-webkit-clip-path','inset(0 0 100% 0)')
 ));
 const useClip = canClipInset && !prefersReduced;

 // durations from CSS vars
 function readDur(varName, fallbackSec) {
 const v = getComputedStyle(document.documentElement).getPropertyValue(varName).trim();
 if (!v) return fallbackSec;
 if (v.endsWith('ms')) return parseFloat(v)/1000;
 if (v.endsWith('s')) return parseFloat(v);
 const n = parseFloat(v);
 return isNaN(n) ? fallbackSec : n;
 }
 const OPEN_DUR = readDur('--nav--menu-open-duration', 0.8);
 const CLOSE_DUR = readDur('--nav--menu-close-duration', 0.4);

 // state per component
 let isOpen = false;
 let current = null;

 function setMenuVisibleForAnim() {
 menu.style.display = 'flex'; // ensure it's shown before anim
 menu.removeAttribute('hidden');
 menu.setAttribute('aria-hidden', 'false');
 menu.style.willChange = useClip ? 'clip-path' : 'transform, opacity';
 }
 function clearMenuInline() {
 gsap.set(menu, { clearProps: 'clipPath,webkitClipPath,opacity,transform,willChange,pointerEvents' });
 }

 // OPEN
 function playOpen() {
 setMenuVisibleForAnim();
 menu.style.pointerEvents = 'none';
 document.body.classList.add('is-nav-open');
 btn.setAttribute('aria-expanded', 'true');

 if (useClip) {
 gsap.set(menu, { clipPath: 'inset(0 0 100% 0)', webkitClipPath: 'inset(0 0 100% 0)' });
 } else {
 gsap.set(menu, { yPercent: -2, opacity: 0 });
 }
 if (items.length) gsap.set(items, { y: 20, autoAlpha: 0 });
 if (actions) gsap.set(actions, { y: 20, autoAlpha: 0 });

 const tl = gsap.timeline({ defaults: { ease: 'power3.out' } });

 if (useClip) {
 tl.to(menu, {
 clipPath: 'inset(0 0 0% 0)',
 webkitClipPath: 'inset(0 0 0% 0)',
 duration: prefersReduced ? 0.01 : OPEN_DUR,
 ease: 'expo.out'
 }, 0);
 } else {
 tl.to(menu, { yPercent: 0, opacity: 1, duration: prefersReduced ? 0.01 : Math.min(OPEN_DUR, 0.36) }, 0.02);
 }

 if (items.length) {
 tl.to(items, { y: 0, autoAlpha: 1, stagger: prefersReduced ? 0 : 0.08, duration: prefersReduced ? 0.01 : 0.4 }, 0.10);
 }
 if (actions) {
 const base = 0.10 + (items.length ? items.length * (prefersReduced ? 0 : 0.08) : 0);
 tl.to(actions, { y: 0, autoAlpha: 1, duration: prefersReduced ? 0.01 : 0.4 }, base);
 }

 tl.add(() => { menu.style.pointerEvents = 'auto'; }, '>-0.1');

 // listeners (per open)
 document.addEventListener('keydown', onKeydown);
 menu.addEventListener('click', onMenuLinkClick);

 return tl;
 }

 // CLOSE (fade all together, then clip inset close)
 function playClose() {
 menu.style.pointerEvents = 'none';
 btn.setAttribute('aria-expanded', 'false');
 document.body.classList.remove('is-nav-open');

 const tl = gsap.timeline({ defaults: { ease: 'power3.out' } });

 const fadeTargets = items.concat(actions ? [actions] : []);
 if (fadeTargets.length) tl.to(fadeTargets, { autoAlpha: 0, y: 0, duration: prefersReduced ? 0.01 : 0.2 }, 0);

 if (useClip) {
 gsap.set(menu, { clipPath: 'inset(0 0 0% 0)', webkitClipPath: 'inset(0 0 0% 0)' });
 tl.to(menu, {
 clipPath: 'inset(0 0 100% 0)',
 webkitClipPath: 'inset(0 0 100% 0)',
 duration: prefersReduced ? 0.01 : CLOSE_DUR
 }, '>-0.02');
 } else {
 tl.to(menu, { yPercent: -2, opacity: 0, duration: prefersReduced ? 0.01 : Math.min(CLOSE_DUR, 0.28) }, '>-0.02');
 }

 tl.add(() => {
 menu.style.display = 'none';
 menu.setAttribute('aria-hidden', 'true');
 clearMenuInline();
 if (items.length) gsap.set(items, { clearProps: 'all' });
 if (actions) gsap.set(actions, { clearProps: 'all' });

 // remove listeners added on open
 document.removeEventListener('keydown', onKeydown);
 menu.removeEventListener('click', onMenuLinkClick);
 });

 return tl;
 }

 function openMenu() {
 if (isOpen) return;
 isOpen = true;
 if (current && current.isActive()) current.kill();
 current = playOpen();
 }
 function closeMenu() {
 if (!isOpen) return;
 isOpen = false;
 if (current && current.isActive()) current.kill();
 current = playClose();
 }

 function onKeydown(e){ if (e.key === 'Escape' && isOpen) { e.preventDefault(); closeMenu(); } }

 function onMenuLinkClick(e){
 const a = e.target.closest('a[href]');
 if (!a) return;
 const url = new URL(a.href, location.href);
 if (url.origin === location.origin) {
 e.preventDefault();
 const tl = playClose();
 tl.eventCallback('onComplete', () => { window.location.href = a.href; });
 isOpen = false;
 }
 }

 // Toggle (scoped)
 btn.addEventListener('click', () => (isOpen ? closeMenu() : openMenu()));

 // Normalize if visible on load (scoped)
 if (getComputedStyle(menu).display !== 'none') {
 btn.setAttribute('aria-expanded', 'true');
 menu.setAttribute('aria-hidden', 'false');
 document.body.classList.add('is-nav-open');
 isOpen = true;
 }
 });
});

 (function () {
 'use strict';

 // ---------- tiny utils ----------
 var NS = 'navBundleInit';
 function onceFlag(el, k){ k=k||'scriptInitialized'; if (el.dataset[k]) return true; el.dataset[k]='true'; return false; }
 function ready(fn){ if(document.readyState==='loading'){document.addEventListener('DOMContentLoaded',fn,{once:true});} else { fn(); } }

 // ---------- 1) Ask Claude about this page ----------
 function initAskPage(){
 var buttons = document.querySelectorAll('[data-ask-page]');
 if (!buttons.length) return; // Early exit if no buttons

 buttons.forEach(function(btn){
 if (onceFlag(btn, NS)) return;
 btn.addEventListener('click', function (e) {
 e.preventDefault();
 var pageUrl = window.location.href;
 var prompt = "Read this page " + pageUrl + " so that I can ask you questions about it";
 var claudeUrl = new URL('https://claude.ai/new');
 claudeUrl.searchParams.set('q', prompt);
 window.open(claudeUrl.toString(), '_blank', 'noopener');
 });
 });
 }

 // ---------- 2) Copy page content as Markdown (Turndown) ----------
 var _turndownReady;
 function ensureTurndown(){
 if (window.TurndownService) return Promise.resolve();
 if (_turndownReady) return _turndownReady;
 _turndownReady = new Promise(function(resolve, reject){
 var s = document.createElement('script');
 s.src = 'https://unpkg.com/turndown/dist/turndown.js';
 s.async = true;
 s.onload = function(){ resolve(); };
 s.onerror = function(){ reject(new Error('Failed to load Turndown')); };
 document.head.appendChild(s);
 });
 return _turndownReady;
 }

 function initCopyAsMarkdown(){
 var copyButton = document.getElementById('copy-as-markdown');
 if (!copyButton) return; // Early exit

 if (onceFlag(copyButton, NS)) return;

 var buttonTextEl = copyButton.querySelector('.nav_dropdown_text') || copyButton;
 var originalText = buttonTextEl.textContent;

 copyButton.addEventListener('click', function(){
 ensureTurndown().then(function(){
 try {
 var TurndownService = window.TurndownService;
 var turndownService = new TurndownService({
 headingStyle: 'atx',
 codeBlockStyle: 'fenced',
 fence: '```',
 emDelimiter: '*',
 strongDelimiter: '**',
 linkStyle: 'inlined'
 });

 // Skip junk
 turndownService.addRule('skipWebflowElements', {
 filter: function(node){
 return node.nodeName === 'SCRIPT' ||
 node.nodeName === 'STYLE' ||
 (node.className && (String(node.className).includes('w-editor') || String(node.className).includes('w-embed')));
 },
 replacement: function(){ return ''; }
 });

 buttonTextEl.textContent = 'Copying...';
 copyButton.disabled = true;

 var contentElement = document.querySelector('main') ||
 document.querySelector('.main-content') ||
 document.querySelector('body');
 if (!contentElement) throw new Error('No content found to copy');

 var cloned = contentElement.cloneNode(true);
 cloned.querySelectorAll('script, style, nav, footer, .w-nav, .footer').forEach(function(el){ el.remove(); });

 var markdown = turndownService.turndown(cloned);

 var done = function(){
 buttonTextEl.textContent = 'Copied!';
 setTimeout(function(){
 buttonTextEl.textContent = originalText;
 copyButton.disabled = false;
 }, 2000);
 };

 if (navigator.clipboard && window.isSecureContext) {
 navigator.clipboard.writeText(markdown).then(done, function(err){ throw err; });
 } else {
 var ta = document.createElement('textarea');
 ta.value = markdown; ta.style.position='fixed'; ta.style.opacity='0';
 document.body.appendChild(ta); ta.select(); document.execCommand('copy'); document.body.removeChild(ta);
 done();
 }
 } catch (err){
 console.error('Copy failed:', err);
 buttonTextEl.textContent = 'Copy failed';
 setTimeout(function(){
 buttonTextEl.textContent = originalText;
 copyButton.disabled = false;
 }, 2000);
 }
 }).catch(function(err){
 console.error('Turndown load failed:', err);
 buttonTextEl.textContent = 'Copy failed';
 setTimeout(function(){
 buttonTextEl.textContent = originalText;
 copyButton.disabled = false;
 }, 2000);
 });
 });
 }

 // ---------- init all ----------
 ready(function(){
 initAskPage();
 initCopyAsMarkdown();
 });

 // Optional: expose minimal API for debugging (comment out in production if not needed)
 // window.NavBundle = {
 // initCopyAsMarkdown: initCopyAsMarkdown,
 // initAskPage: initAskPage
 // };
 })();
Explore here
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - 
THUMBNAIL BG COLORS
- - - - - - - - - - - - - - - - - - - - - - - - - - - - */
[data-thumbnail-bg="Clay"] { background-color: var(--swatch--clay); }
[data-thumbnail-bg="Cactus"] { background-color: var(--swatch--cactus); }
[data-thumbnail-bg="Coral"] { background-color: var(--swatch--coral); }
[data-thumbnail-bg="Fig"] { background-color: var(--swatch--fig); }
[data-thumbnail-bg="Heather"] { background-color: var(--swatch--heather); }
[data-thumbnail-bg="Oat"] { background-color: var(--swatch--oat); }
[data-thumbnail-bg="Olive"] { background-color: var(--swatch--olive); }
[data-thumbnail-bg="Sky"] { background-color: var(--swatch--sky); }

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - 
CONDITIONAL STYLES BASED ON IF IMAGE OR VIDEO ARE VISIBLE
- - - - - - - - - - - - - - - - - - - - - - - - - - - - */
.hero_tutorial_post_wrap:has(+ .tutorial_post_media_wrap :is(.tutorial_post_image_wrap, .tutorial_post_video_wrap):not(.w-condition-invisible)) {
 border-bottom: none !important;
}

.tutorial_post_media_wrap:has(+ .tutorial_post_wrap:not(.w-condition-invisible)) .u-section-spacer {
 display: none !important;
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - 
TABLE OF CONTENTS
Adding here so classes don't get accidentally cleared
- - - - - - - - - - - - - - - - - - - - - - - - - - - - */
.tutorial_post_toc_list {
 color: var(--_theme---foreground-tertiary); 
 font-size: var(--_typography---font-size--body-3);
}

.tutorial_post_toc_item {
 margin-left: -0.0625rem; 
 padding-top: var(--_spacing---space--0-25rem);
 padding-bottom: var(--_spacing---space--0-25rem); 
 padding-left: var(--_spacing---space--1rem); 
 border-left-style: solid; 
 border-left-width: var(--border-width--main); 
 border-left-color: var(--_theme---border-secondary);
}

.tutorial_post_toc_item.active {
 border-left-color: var(--_theme---heroes-accent);
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - 
ANCHOR LINK
- - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/* offset for <span class="anchor"> that takes fixed header height into account */
.anchor { 
 position: relative;
 top: calc(-1 * var(--_spacing---space--4rem) - 120px); 
}
/* Copy anchor link to clipboard button */
.anchor-link-box {
 /* quick btn reset */
 background: none;
 border: none;
 padding: 0;
 cursor: pointer;
 /* other styles */
 position: absolute !important;
 left: -3rem;
 top: 50%;
 transform: translateY(-50%);
 opacity: 0;
 transition: opacity 0.2s ease;
 width: 2.5rem;
 height: 2.5rem;
 background: var(--_theme---background-tertiary);
 border: var(--border-width--main) solid var(--_theme---border-tertiary);
 border-radius: var(--radius--main);
 display: flex;
 align-items: center;
 justify-content: center;
 padding: var(--_spacing---space--0-5rem);
}

.anchor-link-box:hover {
 opacity: 1;
}

.tooltip {
 opacity: 0;
 transition: opacity 0.2s ease;
 position: absolute;
 left: 50%;
 bottom: calc(100% + 0.5rem);
 transform: translateX(-50%);
 background: var(--_theme---button-primary--background);
 color: var(--_theme---button-primary--text);
 white-space: nowrap;
 padding: 0.125rem 0.5rem;
 border-radius: var(--radius--x-small);
 font-family: var(--_typography---font--primary-family);
 font-size: var(--_typography---font-size--caption);
 line-height: var(--_typography---line-height--1-6);
}

.tooltip.active {
 opacity: 1;
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - 
HIDE EMPTY <p> TAGS
- - - - - - - - - - - - - - - - - - - - - - - - - - - - */
p:empty,
p:has(> br:only-child) {
 display: none;
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - 
BORDER RADIUS ON RICH TEXT VIDEOS
- - - - - - - - - - - - - - - - - - - - - - - - - - - - */
.w-richtext-figure-type-video {
 border-radius: var(--radius--main);
 overflow: hidden;
}
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - 
FIX GRID SPACING IF TUTORIAL HAS NO VIDEO
- - - - - - - - - - - - - - - - - - - - - - - - - - - - */
.tutorial_post_video_layout:has(.w-dyn-bind-empty) {
 display: none;
}

document.addEventListener('DOMContentLoaded', function() {
 // Helper function to convert text to slug
 function textToSlug(text) {
 return text
 .toLowerCase()
 .trim()
 .replace(/[''"&]/g, '')
 .replace(/"([^"]+)"/, '$1')
 .replace(/\s*[:.,?—–\\/-]\s*/g, '-')
 .replace(/\s+/g, '-')
 .replace(/-+/g, '-')
 .replace(/^-+|-+$/g, '');
 }
 
 // Track used slugs to prevent duplicate IDs
 const usedSlugs = new Set();
 
 function getUniqueSlug(baseSlug) {
 let slug = baseSlug;
 let counter = 1;
 while (usedSlugs.has(slug)) {
 slug = `${baseSlug}-${counter}`;
 counter++;
 }
 usedSlugs.add(slug);
 return slug;
 }
 
 // Add/Remove class helper functions
 const addClass = (element, className) => {
 if (element && className) {
 element.classList.add(className);
 }
 };
 
 const removeClass = (element, className) => {
 if (element && className) {
 element.classList.remove(className);
 }
 };
 
 // Debounce helper for resize events
 function debounce(func, wait) {
 let timeout;
 return function executedFunction(...args) {
 const later = () => {
 clearTimeout(timeout);
 func(...args);
 };
 clearTimeout(timeout);
 timeout = setTimeout(later, wait);
 };
 }
 
 // Get elements
 const tutorialContent = document.getElementById('tutorial_content');
 const tocContainer = document.getElementById('tutorial_toc');
 
 if (!tutorialContent || !tocContainer) {
 return;
 }
 
 const h2Elements = tutorialContent.querySelectorAll('h2');
 
 if (h2Elements.length === 0) {
 tocContainer.style.display = 'none';
 return;
 }
 
 // Create ToC list
 const tocList = document.createElement('ul');
 addClass(tocList, 'tutorial_post_toc_list');
 
 const tocItems = [];
 
 // Copy anchor link to clipboard with tooltip
 const copyAnchorToClipboard = (element, spanElement, mouseEnterTime = 750) => {
 let hoverTimeout;
 let tooltip;
 
 element.addEventListener("mouseenter", function () {
 clearTimeout(hoverTimeout);
 tooltip = document.createElement("span");
 addClass(tooltip, 'tooltip');
 tooltip.innerText = "Copy anchor link";
 this.appendChild(tooltip);
 hoverTimeout = setTimeout(() => {
 addClass(tooltip, "active");
 }, mouseEnterTime);
 });

 element.addEventListener("mouseleave", function () {
 clearTimeout(hoverTimeout);
 if (tooltip) {
 removeClass(tooltip, "active");
 this.removeChild(tooltip);
 tooltip = null;
 }
 });

 element.addEventListener("click", function (event) {
 event.preventDefault();
 clearTimeout(hoverTimeout);

 if (spanElement && spanElement.classList.contains("anchor")) {
 const id = spanElement.id;

 if (tooltip) {
 tooltip.innerText = "Copied!";
 addClass(tooltip, "active");

 const url = new URL(window.location.href);
 url.searchParams.delete("topic");
 const anchorLink = `${url.origin}${url.pathname}#${id}`;

 if (navigator && navigator.clipboard) {
 navigator.clipboard.writeText(anchorLink).catch((err) => {
 console.error("Could not copy text: ", err);
 });
 }
 hoverTimeout = setTimeout(() => {
 removeClass(tooltip, "active");
 }, 1500);
 }
 } else {
 console.error("Couldn't find Span with the ID");
 }
 });
 };
 
 // Anchor link SVG icon
 const anchorLinkSVG = `<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 20 20" fill="none"><path d="M7.59608 7.99088C9.01909 7.43035 10.5884 7.86617 11.5326 8.96256L11.7123 9.19108C11.7695 9.27004 11.8243 9.35165 11.8754 9.4362L12.018 9.69792L12.0531 9.79362C12.1116 10.0184 12.0068 10.2611 11.7904 10.3678C11.5738 10.4744 11.3168 10.4098 11.1742 10.2262L11.1205 10.1403L11.018 9.95377C10.9816 9.8936 10.9434 9.83515 10.9027 9.77897L10.7738 9.61491C10.0992 8.83195 8.97855 8.52172 7.96327 8.92155C6.67866 9.42757 6.04713 10.8791 6.55311 12.1637L7.83631 15.4206C8.34249 16.7049 9.794 17.3357 11.0785 16.8298C12.3629 16.3236 12.9937 14.8721 12.4877 13.5876L12.3969 13.3551C12.2957 13.0983 12.4213 12.808 12.6781 12.7067C12.935 12.6055 13.2253 12.732 13.3265 12.9889L13.4183 13.2214C14.1268 15.0198 13.2432 17.052 11.4447 17.7604C9.64625 18.4688 7.61412 17.5852 6.90565 15.7868L5.62245 12.5299C4.91434 10.7317 5.79792 8.69938 7.59608 7.99088ZM8.55506 2.23991C10.3536 1.53146 12.3857 2.41505 13.0941 4.21354L14.3773 7.4694C15.0857 9.26779 14.202 11.2999 12.4037 12.0085C10.9807 12.569 9.41236 12.1332 8.46815 11.0368L8.28749 10.8092C8.17297 10.6512 8.07027 10.481 7.98182 10.3014C7.86013 10.0539 7.96206 9.75458 8.20936 9.63249C8.4571 9.5105 8.7573 9.61229 8.87928 9.86002C8.9425 9.98839 9.0156 10.1089 9.09706 10.2214L9.22596 10.3844C9.90056 11.1677 11.022 11.4788 12.0375 11.0788C13.3218 10.5727 13.9524 9.12105 13.4467 7.83659L12.1644 4.57975C11.6584 3.29511 10.2059 2.66356 8.92128 3.1696C7.63695 3.67569 7.00633 5.12732 7.5121 6.41178L7.60389 6.64518C7.70479 6.902 7.57845 7.19247 7.32167 7.29362C7.06479 7.39475 6.77446 7.26823 6.67323 7.01139L6.58143 6.77897C5.87303 4.98058 6.75677 2.94846 8.55506 2.23991Z" fill="currentColor"/></svg>`;

 // Process each H2 and build ToC
 h2Elements.forEach((h2) => {
 const headingText = h2.textContent;
 const baseSlug = textToSlug(headingText);
 const slug = getUniqueSlug(baseSlug);
 
 // Add anchor span
 const anchorSpan = document.createElement('span');
 anchorSpan.id = slug;
 addClass(anchorSpan, 'anchor');
 h2.prepend(anchorSpan);
 
 // Add anchor link box
 const anchorLinkBox = document.createElement('button');
 anchorLinkBox.type = 'button';
 addClass(anchorLinkBox, 'anchor-link-box');
 anchorLinkBox.innerHTML = anchorLinkSVG;
 h2.prepend(anchorLinkBox);
 
 // Initialize copy functionality
 copyAnchorToClipboard(anchorLinkBox, anchorSpan);
 
 // Create ToC item
 const listItem = document.createElement('li');
 addClass(listItem, 'tutorial_post_toc_item');
 
 const link = document.createElement('a');
 link.href = `#${slug}`;
 
 const textDiv = document.createElement('div');
 textDiv.textContent = headingText;
 
 link.appendChild(textDiv);
 listItem.appendChild(link);
 tocList.appendChild(listItem);
 
 tocItems.push({
 element: listItem,
 target: h2
 });
 });
 
 tocContainer.appendChild(tocList);
 
 // Configuration
 const headerHeight = 134;
 const activationOffset = 100;
 
 // State
 let currentActive = 0;
 let ranges = [];
 let frameRequested = false;
 
 // Calculate activation ranges using getBoundingClientRect for reliability
 // (offsetTop can be relative to offsetParent, not document)
 function calculateRanges() {
 const scrollY = window.scrollY;
 
 ranges = tocItems.map((item, index) => {
 const rect = item.target.getBoundingClientRect();
 const absoluteTop = rect.top + scrollY;
 const activationPoint = absoluteTop - headerHeight - activationOffset;
 
 const nextAbsoluteTop = index < tocItems.length - 1
 ? tocItems[index + 1].target.getBoundingClientRect().top + scrollY
 : Infinity;
 const nextActivation = nextAbsoluteTop === Infinity 
 ? Infinity 
 : nextAbsoluteTop - headerHeight - activationOffset;
 
 return {
 index: index,
 start: Math.max(0, activationPoint),
 end: nextActivation
 };
 });
 }
 
 // Update active section
 function updateActiveSection() {
 if (ranges.length === 0) return;
 
 const scrollPosition = window.scrollY;
 let newActive = 0;
 
 // Find current range
 if (scrollPosition < ranges[0].start) {
 newActive = 0;
 } else {
 for (let i = 0; i < ranges.length; i++) {
 if (scrollPosition >= ranges[i].start && scrollPosition < ranges[i].end) {
 newActive = i;
 break;
 }
 }
 }
 
 // Special case: if near bottom of page, activate last item
 const scrollBottom = scrollPosition + window.innerHeight;
 const documentHeight = document.documentElement.scrollHeight;
 if (documentHeight - scrollBottom < 100) {
 newActive = tocItems.length - 1;
 }
 
 // Update classes if changed
 if (newActive !== currentActive) {
 tocItems.forEach(item => removeClass(item.element, 'active'));
 currentActive = newActive;
 if (tocItems[currentActive]) {
 addClass(tocItems[currentActive].element, 'active');
 }
 }
 
 frameRequested = false;
 }
 
 // Scroll handler
 function handleScroll() {
 if (!frameRequested) {
 frameRequested = true;
 window.requestAnimationFrame(updateActiveSection);
 }
 }
 
 // Recalculate on resize (debounced)
 const handleResize = debounce(() => {
 calculateRanges();
 updateActiveSection();
 }, 250);
 
 // Smooth scroll behavior for ToC links
 tocItems.forEach(item => {
 item.element.querySelector('a').addEventListener('click', function(e) {
 e.preventDefault();
 const targetId = this.getAttribute('href').substring(1);
 const targetElement = document.getElementById(targetId);
 
 if (targetElement) {
 const scrollTo = targetElement.parentElement.offsetTop - headerHeight - 20;
 window.scrollTo({
 top: scrollTo,
 behavior: 'smooth'
 });
 }
 });
 });
 
 // Initialize
 calculateRanges();
 addClass(tocItems[0].element, 'active');
 
 // Handle hash on initial page load
 if (window.location.hash) {
 const hash = window.location.hash.substring(1);
 const targetIndex = tocItems.findIndex(item => 
 item.target.querySelector('.anchor')?.id === hash
 );
 if (targetIndex !== -1) {
 tocItems.forEach(item => removeClass(item.element, 'active'));
 addClass(tocItems[targetIndex].element, 'active');
 currentActive = targetIndex;
 }
 }
 
 // Re-check after browser might restore scroll position
 requestAnimationFrame(() => {
 requestAnimationFrame(() => {
 calculateRanges();
 updateActiveSection();
 });
 });
 
 // Event listeners
 window.addEventListener('scroll', handleScroll, { passive: true });
 window.addEventListener('resize', handleResize);
 
 // Visual Viewport API for mobile viewport changes (keyboard, browser chrome)
 if (window.visualViewport) {
 window.visualViewport.addEventListener('resize', handleResize);
 window.visualViewport.addEventListener('scroll', handleResize);
 }
 
 // Browser back/forward navigation with hash changes
 window.addEventListener('popstate', () => {
 calculateRanges();
 updateActiveSection();
 });
 
 // Handle dynamic content changes (if Webflow adds/removes content)
 const observer = new MutationObserver(debounce(() => {
 calculateRanges();
 updateActiveSection();
 }, 500));
 
 observer.observe(tutorialContent, {
 childList: true,
 subtree: true,
 attributes: false
 });
 
 // Recalculate after images load (affects layout positions)
 const images = tutorialContent.querySelectorAll('img');
 images.forEach(img => {
 if (!img.complete) {
 img.addEventListener('load', handleResize, { once: true });
 img.addEventListener('error', handleResize, { once: true });
 }
 });
 
 // Recalculate after fonts load
 if (document.fonts && document.fonts.ready) {
 document.fonts.ready.then(handleResize);
 }
});
Getting Started with Claude for Life SciencesCategoryLife SciencesProductClaude.aiReading timeWatch time3minminShareCopy linkhttps://claude.com/resources/tutorials/getting-started-with-claude-for-life-sciencesWhat is Claude for Life SciencesClaude for Life Sciences enhances Claude with specialized capabilities for life sciences researchers and organizations. It connects Claude to the data sources, tools, and systems that teams use daily across R&D, clinical operations, and regulatory affairs — eliminating the need to toggle between platforms and enabling insights that span your entire product lifecycle. The result: accelerated timelines from discovery through approval, with the rigor and traceability these workflows demand.How do I access life sciences tools and features?Individuals can access Claude for Life Sciences features and tools from a Claude Pro or Claude Max account, and teams can access through Claude for Work. For questions about Claude for Life Sciences for enterprise contact our Sales team.Connectors for the life sciences development cycleThrough Model Context Protocol (MCP) connectors and desktop extensions, Claude connects directly to leading platforms and databases, enabling you to query data using natural language and receive responses with source citations.Scientific research & discoveryBenchling connects Claude to Benchling R&D platform data, enabling scientists to ask questions and receive clear summaries with links back to source experiments, notebooks, and structured records—all while maintaining existing access permissions.10x Genomics* transforms single cell and spatial analysis into a simple, conversational workflow. Biologists can easily analyze their own sequencing data, while core labs can quickly perform batch processing.PubMed provides access to millions of biomedical research articles and clinical studies, allowing Claude to access abstracts and full papers to clarify experimental approaches, identify key findings, determine novelty and applicability, and surface specific papers for deeper explorationSynapse.org allows researchers to discover biomedical data across all of Synapse, see the structure of projects, and retrieve information on their data assets for authorized users.BioRender searches BioRender's extensive scientific figure template and icon collection for relevant content to create figures faster.Scholar Gateway by Wiley provides authenticated access to the most relevant snippets of scientific research papers to utilize within Claude. bioRxiv / medRxiv gives Claude access to bioRxiv and medRxiv preprint servers, enabling researchers to search, retrieve, and analyze non-peer-reviewed scientific manuscripts in biological and health sciences before formal journal publication.‍ChEMBL gives Claude access to a manually curated repository of bioactive molecules with drug-like properties, their biological targets, and quantitative activity measurements.‍ToolUniverse* gives Claude access to a library of 600+ vetted scientific tools to explore large hypothesis spaces, compare competing hypotheses, and iterate through fast-to-slow cycles of analysis.‍Owkin powers Pathology Explorer, an Owkin AI agent that transforms H&E pathology slides into queryable insights for drug discovery and development and clinical research.Open Targets gives Claude access to the Open Targets Platform for identifying and prioritizing therapeutic drug targets based on disease associations.‍Clinical operations & regulatoryMedidata, a leader in clinical trial solutions, provides the ability to connect Claude to their Medidata platform dataClinicalTrials.gov gives Claude access to the NIH/NLM registry of 500,000+ clinical studies to search trials, analyze endpoints, and support research operations.*Available as Desktop Extensions for access on Claude Desktop App (download here).Claude also includes Connectors to other workplace and productivity platforms like Microsoft 365, Gmail & Google Drive, Box, Databricks, Slack, and many more. Explore all available Claude Connectors here.You can also add custom connectors to connect Claude directly to the tools and data sources that matter most to your workflows. Learn more about setting up custom connectors here.Common research & discovery use casesAdvanced data analysis and hypothesis generation: Synthesize multi-source data to accelerate discovery cycles from weeks to hours.‍Literature synthesis with citations: Access abstracts and full papers to clarify experimental approaches, identify key findings, determine novelty and applicability, and surface specific papers for deeper exploration.‍Protocol optimization: Generate optimized protocols by synthesizing literature, successful existing protocols, and experimental best practices.‍Single-cell data processing: Synthesize days of bioinformatics and computational analysis in minutes with automated cell population identification. Check out the single-cell-rna-qc skill which gives Claude the ability to perform quality control on single-cell RNA-seq data using scverse best practices.‍Experimental design automation: Generate literature-informed experimental designs automatically.‍Figure interpretation and analysis: Accelerate figure creation and analysis with automated visualization.What is Claude for Life SciencesHow do I access life sciences tools and features?Connectors for the life sciences development cycleCommon research & discovery use casesRelated tutorialsHow to use the Scientific Problem Selection Skill with ClaudeHow to use the Scientific Problem Selection Skill with ClaudeHow to use the Scientific Problem Selection Skill with ClaudeTutorialTutorialTutorialHow to use the scVI-Tools bioinformatics skill bundle with ClaudeHow to use the scVI-Tools bioinformatics skill bundle with ClaudeHow to use the scVI-Tools bioinformatics skill bundle with ClaudeTutorialTutorialTutorialUsing the ClinicalTrials.gov Connector in ClaudeUsing the ClinicalTrials.gov Connector in ClaudeUsing the ClinicalTrials.gov Connector in ClaudeTutorialTutorialTutorial Using the ToolUniverse Extension in Claude Using the ToolUniverse Extension in Claude Using the ToolUniverse Extension in ClaudeTutorialTutorialTutorial
 @container (width < 52em) {
 .footer_layout {
 display: flex;
 column-gap: var(--_spacing---space--4rem);
 row-gap: var(--_spacing---space--4rem);
 }
 .footer_content_wrap.u-column-custom {
 display: contents;
 }
 }

 .footer_link {
 opacity: 1;
 transition: opacity 0.3s ease;
 }
 .footer_links_list:has(.footer_link:hover) .footer_link:not(:hover) {
 opacity: 0.4;
 }
HomepageHomepageNextNextThank you! Your submission has been received!Oops! Something went wrong while submitting the form.
 (function () {
 const ROOT_SEL = "[data-prompt-scope]";
 const TRIGGER_SEL = "[data-prompt-trigger]";
 const MENU_ATTR = "data-prompt-menu";
 const CLOSE_SEL = "[data-prompt-menu-close]";
 const ACTION_SEL = "a, button, [data-prompt-menu-action]";
 const ITEM_SEL = "[data-prompt-item], li, .menu-item, .w-dyn-item";

 // ---------- Claude helper ----------
 function buildClaudeUrl(text) {
 const url = new URL("https://claude.ai/new");
 url.searchParams.set("q", text || "");
 return url.toString();
 }
 function openClaude(text) {
 const q = (text || "").trim();
 if (!q) return;
 window.open(buildClaudeUrl(q), "_blank", "noopener");
 }

 // ---------- Utilities ----------
 let uid = 0;
 function makeId(prefix = "prompt-menu") {
 uid += 1;
 return `${prefix}-${Date.now().toString(36)}-${uid}`;
 }

 // Limit queries to elements that belong to THIS scope (ignore nested scopes)
 function qsaInScope(root, sel) {
 return Array.from(root.querySelectorAll(sel)).filter(
 (el) => el.closest(ROOT_SEL) === root
 );
 }

 // Lightweight shield to stop click-through during the brief close animation
 function deployClickShield(ms = 300) {
 const sh = document.createElement("div");
 sh.style.cssText =
 "position:fixed;inset:0;z-index:2147483647;pointer-events:auto;background:transparent";
 document.body.appendChild(sh);
 setTimeout(() => {
 sh.remove();
 }, ms);
 }

 // Pairing: find which menu a trigger controls (no manual ids needed)
 function resolveMenuForTrigger(root, trigger) {
 // 1) explicit data-prompt-trigger="x" -> [data-prompt-menu="x"]
 const explicit = trigger.getAttribute("data-prompt-trigger");
 if (explicit) {
 const m = qsaInScope(root, `[${MENU_ATTR}="${explicit}"]`)[0];
 if (m) return m;
 }
 // 2) aria-controls
 const ctrl = trigger.getAttribute("aria-controls");
 if (ctrl) {
 const m = qsaInScope(root, `#${ctrl.replace(/(["'\\])/g, "\\$1")}`)[0];
 if (m) return m;
 }
 // 3) nearest following sibling with [data-prompt-menu]
 let sib = trigger.nextElementSibling;
 while (sib && sib !== root) {
 if (
 sib.hasAttribute &&
 sib.hasAttribute(MENU_ATTR) &&
 sib.closest(ROOT_SEL) === root
 )
 return sib;
 sib = sib.nextElementSibling;
 }
 // 4) first menu in this root
 return qsaInScope(root, `[${MENU_ATTR}]`)[0] || null;
 }

 function ensurePairing(trigger, menu) {
 if (!menu.id) menu.id = makeId();
 trigger.setAttribute("aria-controls", menu.id);
 if (trigger.tagName === "BUTTON" && !trigger.hasAttribute("type"))
 trigger.type = "button";
 }

 // ---------- Animations (GSAP) ----------
 function revealMenu(menu) {
 return new Promise((resolve) => {
 gsap.set(menu, {
 visibility: "visible",
 pointerEvents: "auto",
 willChange: "transform, opacity",
 });
 gsap.killTweensOf(menu);
 gsap.fromTo(
 menu,
 { opacity: 0, scale: 0.96 },
 {
 opacity: 1,
 scale: 1,
 duration: 0.28,
 ease: "power3.out",
 clearProps: "willChange",
 onComplete: resolve,
 }
 );
 });
 }
 function hideMenu(menu) {
 return new Promise((resolve) => {
 gsap.killTweensOf(menu);
 gsap.to(menu, {
 opacity: 0,
 duration: 0.2,
 ease: "power2.out",
 onComplete: () => {
 gsap.set(menu, {
 visibility: "hidden",
 pointerEvents: "none",
 clearProps: "opacity,scale,willChange",
 });
 resolve();
 },
 });
 });
 }

 // ---------- Per-scope controller ----------
 const stateMap = new WeakMap(); // root -> { openMenuEl, openTrigger, isAnimating }

 function getState(root) {
 let s = stateMap.get(root);
 if (!s) {
 s = { openMenuEl: null, openTrigger: null, isAnimating: false };
 stateMap.set(root, s);
 }
 return s;
 }

 function setTriggersInteractive(root, enabled) {
 qsaInScope(root, TRIGGER_SEL).forEach((el) => {
 el.style.pointerEvents = enabled ? "auto" : "none";
 });
 }

 // ---------- Button fade animations ----------
 function fadeOutButtons(root) {
 return new Promise((resolve) => {
 const buttons = qsaInScope(root, TRIGGER_SEL);
 if (buttons.length === 0) {
 resolve();
 return;
 }

 gsap.killTweensOf(buttons);
 gsap.to(buttons, {
 autoAlpha: 0,
 duration: 0.2,
 ease: "power2.out",
 onComplete: resolve,
 });
 });
 }

 function fadeInButtons(root) {
 return new Promise((resolve) => {
 const buttons = qsaInScope(root, TRIGGER_SEL);
 if (buttons.length === 0) {
 resolve();
 return;
 }

 gsap.killTweensOf(buttons);
 gsap.to(buttons, {
 autoAlpha: 1,
 duration: 0.2,
 ease: "power2.out",
 onComplete: resolve,
 });
 });
 }

 async function openMenuIn(root, menu, trigger) {
 const s = getState(root);
 if (s.isAnimating || s.openMenuEl === menu) return;
 s.isAnimating = true;

 // close any currently open in THIS scope only
 if (s.openMenuEl && s.openMenuEl !== menu) {
 await hideMenu(s.openMenuEl);
 if (s.openTrigger) s.openTrigger.setAttribute("aria-expanded", "false");
 }

 // Fade out buttons when opening menu
 await fadeOutButtons(root);

 await revealMenu(menu);
 s.openMenuEl = menu;
 s.openTrigger = trigger || null;
 if (s.openTrigger) s.openTrigger.setAttribute("aria-expanded", "true");

 // Disable only this scope's triggers while open
 setTriggersInteractive(root, false);

 s.isAnimating = false;
 }

 async function closeMenuIn(root) {
 const s = getState(root);
 if (!s.openMenuEl || s.isAnimating) return;
 s.isAnimating = true;

 deployClickShield(280); // prevent click-through during closing
 await hideMenu(s.openMenuEl);

 if (s.openTrigger) s.openTrigger.setAttribute("aria-expanded", "false");
 s.openMenuEl = null;
 s.openTrigger = null;

 // Re-enable only this scope's triggers
 setTriggersInteractive(root, true);

 // Fade in buttons when closing menu
 await fadeInButtons(root);

 s.isAnimating = false;
 }

 // ---------- Initializer ----------
 const initedRoots = new WeakSet();

 function initScope(root) {
 if (!root || initedRoots.has(root)) return;
 initedRoots.add(root);

 if (!window.gsap) {
 console.warn("GSAP is required for prompt menus.");
 return;
 }

 // Normalize ALL menus in this scope to hidden on init (prevents “open on load” bugs)
 qsaInScope(root, `[${MENU_ATTR}]`).forEach((menu) => {
 if (menu.dataset.pmMenuInit) return;
 menu.dataset.pmMenuInit = "true";
 gsap.set(menu, {
 visibility: "hidden",
 opacity: 0,
 scale: 1,
 pointerEvents: "none",
 });

 // Optional close button
 const closer = menu.querySelector(CLOSE_SEL);
 if (closer) {
 if (closer.tagName === "BUTTON" && !closer.hasAttribute("type"))
 closer.type = "button";
 closer.addEventListener("click", (e) => {
 e.preventDefault();
 e.stopPropagation();
 closeMenuIn(root);
 });
 }

 // Menu item -> Claude
 menu.addEventListener("click", (e) => {
 const target = e.target.closest(ACTION_SEL);
 if (!target || !menu.contains(target)) return;

 const container = target.closest(ITEM_SEL) || target;
 const hiddenP = container.querySelector("[data-prompt-menu-text]");
 if (!hiddenP) return;

 e.preventDefault();
 e.stopPropagation();

 const text = hiddenP.textContent || hiddenP.innerText || "";
 openClaude(text);

 // close after action
 closeMenuIn(root);
 });
 });

 // Bind triggers (auto-wire)
 qsaInScope(root, TRIGGER_SEL).forEach((trigger) => {
 if (trigger.dataset.pmTrigInit) return;
 trigger.dataset.pmTrigInit = "true";

 const menu = resolveMenuForTrigger(root, trigger);
 if (menu) ensurePairing(trigger, menu);

 trigger.setAttribute("aria-expanded", "false");

 trigger.addEventListener("click", async (e) => {
 e.preventDefault();

 const targetMenu = resolveMenuForTrigger(root, trigger);
 if (!targetMenu) return;

 const s = getState(root);
 if (s.openMenuEl === targetMenu) {
 await closeMenuIn(root); // toggle close
 return;
 }
 await openMenuIn(root, targetMenu, trigger);
 });
 });

 // Outside click (this scope only)
 document.addEventListener("click", (e) => {
 const s = getState(root);
 if (!s.openMenuEl) return;
 const insideMenu = s.openMenuEl.contains(e.target);
 const onTrigger =
 !!e.target.closest(TRIGGER_SEL) && root.contains(e.target);
 if (!insideMenu && !onTrigger) closeMenuIn(root);
 });

 // ESC (this scope only)
 document.addEventListener("keydown", (e) => {
 if (e.key === "Escape") closeMenuIn(root);
 });
 }

 // ---------- Boot + observe ----------
 function boot(container = document) {
 const roots = container.querySelectorAll
 ? container.querySelectorAll(ROOT_SEL)
 : [];
 roots.forEach(initScope);
 }

 if (document.readyState === "loading") {
 document.addEventListener("DOMContentLoaded", () => boot(), {
 once: true,
 });
 } else {
 boot();
 }

 const mo = new MutationObserver((muts) => {
 for (const m of muts) {
 for (const node of m.addedNodes || []) {
 if (node.nodeType !== 1) continue;
 if (node.matches && node.matches(ROOT_SEL)) initScope(node);
 if (node.querySelectorAll) {
 node.querySelectorAll(ROOT_SEL).forEach(initScope);
 }
 }
 }
 });
 mo.observe(document.documentElement, { childList: true, subtree: true });
 })();

(function () {
 // ---------- Claude helper ----------
 function buildClaudeUrl(text) {
 const url = new URL('https://claude.ai/new');
 url.searchParams.set('q', text || '');
 return url.toString();
 }

 // ---------- Auto-grow helpers ----------
 function sizeTextarea(el) {
 // Ensure UA defaults don't force a starting height
 el.setAttribute('rows', el.getAttribute('data-min-rows') || '1');
 el.style.minHeight = '0px';
 el.style.height = 'auto'; // allow shrink
 el.style.height = el.scrollHeight + 'px'; // fit content
 }

 function initAutogrow(root = document) {
 root.querySelectorAll('textarea[data-autogrow]').forEach((el) => {
 if (el.dataset.autogrowInit) return;
 el.dataset.autogrowInit = 'true';

 // Respect your existing pattern for default text
 const preset = el.getAttribute('data-default-text');
 if (preset != null && !el.value) el.value = preset;

 // Initial sizing
 sizeTextarea(el);

 // Resize as you type
 el.addEventListener('input', () => sizeTextarea(el));

 // In case fonts/styles load late and change line-height
 window.addEventListener('load', () => sizeTextarea(el), { once: true });
 });
 }

 // ---------- Claude form initializer ----------
 function initClaudeForms(root = document) {
 root.querySelectorAll('form[data-claude-form]').forEach((form) => {
 if (form.dataset.claudeInit) return;
 form.dataset.claudeInit = 'true';

 const textarea = form.querySelector('[data-claude-textarea], textarea');
 const trigger = form.querySelector('[data-claude-button], button[type="button"], a[data-claude-button]');

 if (!textarea || !trigger) {
 console.warn('Claude form: missing textarea or trigger in', form);
 return;
 }

 // If the trigger is a <button> but has no type, force "button" so it won't submit
 if (trigger.tagName === 'BUTTON' && !trigger.hasAttribute('type')) {
 trigger.type = 'button';
 }

 // Keep <a> from navigating away while still opening Claude
 if (trigger.tagName === 'A') {
 trigger.addEventListener('click', (e) => e.preventDefault());
 }

 // Optional: support data-default-text on the textarea
 const preset = textarea.getAttribute('data-default-text');
 if (preset != null && !textarea.value) textarea.value = preset;

 // Click opens Claude; submission is optional
 trigger.addEventListener('click', () => {
 const text = (textarea.value || '').trim();
 if (!text) {
 textarea.focus();
 return;
 }

 window.open(buildClaudeUrl(text), '_blank', 'noopener');

 const mode = form.getAttribute('data-claude-mode') || 'intercept';
 if (mode === 'also') {
 // Submit after opening Claude
 form.submit();
 }
 // intercept mode: do nothing (no submit)
 });

 // (Optional) Keep an <a data-claude-button> href in sync for right-click/open-in-new-tab UX
 if (trigger.tagName === 'A') {
 const syncHref = () => trigger.setAttribute('href', buildClaudeUrl((textarea.value || '').trim()));
 syncHref();
 textarea.addEventListener('input', syncHref);
 textarea.addEventListener('change', syncHref);
 }
 });
 }

 // ---------- Boot ----------
 function initAll(root = document) {
 initAutogrow(root);
 initClaudeForms(root);
 }

 if (document.readyState === 'loading') {
 document.addEventListener('DOMContentLoaded', () => initAll(), { once: true });
 } else {
 initAll();
 }

 // Re-init if content is injected later (Webflow CMS / IX / tabs)
 const mo = new MutationObserver((muts) => {
 for (const m of muts) {
 for (const node of m.addedNodes || []) {
 if (node.nodeType === 1) initAll(node);
 }
 }
 });
 mo.observe(document.documentElement, { childList: true, subtree: true });
})();

 .prompt_menu_item {
 transition: border-color 0.2s ease, color 0.2s ease;
 }
 .prompt_menu_item_base, .prompt_menu_item_icon {
 transition: opacity 0.2s ease;
 }
 .prompt_menu_list .prompt_menu_item:first-child {
 border-color: transparent;
 }
 .prompt_menu_item:hover {
 border-color: transparent;
 color: var(--_theme---foreground-primary);
 }
 .prompt_menu_item:hover .prompt_menu_item_base {
 opacity: 1;
 }
 .prompt_menu_item:hover .prompt_menu_item_icon {
 opacity: 1;
 }
 .prompt_menu_item:hover + .prompt_menu_item {
 border-top-color: transparent;
 }

 .button_prompt_icon {
 transition: color 0.3s ease;
 }
 .button_prompt_wrap:hover .button_prompt_icon {
 color: var(--_button-style---icon-hover); 
 }
 .button_prompt_wrap:focus-within .button_prompt_icon {
 color: var(--_button-style---text-hover) !important;
 }
 .button_prompt_wrap:focus-within {
 color: var(--_button-style---text-hover) !important;
 }

WriteButton TextButton TextLearnButton TextButton TextCodeButton TextButton TextWriteHelp me develop a unique voice for an audienceHi Claude! Could you help me develop a unique voice for an audience? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational. Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!Improve my writing styleHi Claude! Could you improve my writing style? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational. Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!Brainstorm creative ideasHi Claude! Could you brainstorm creative ideas? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational. Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!LearnExplain a complex topic simplyHi Claude! Could you explain a complex topic simply? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational. Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!Help me make sense of these ideasHi Claude! Could you help me make sense of these ideas? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational. Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!Prepare for an exam or interviewHi Claude! Could you prepare for an exam or interview? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational. Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!CodeExplain a programming conceptHi Claude! Could you explain a programming concept? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational. Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!Look over my code and give me tipsHi Claude! Could you look over my code and give me tips? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational. Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!Vibe code with meHi Claude! Could you vibe code with me? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational. Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!MoreWrite case studiesThis is another testWrite grant proposalsHi Claude! Could you write grant proposals? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to — like Google Drive, web search, etc. — if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational. Please execute the task as soon as you can - an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!Write video scriptsthis is a testAnthropicAnthropic© 2026 Anthropic PBCProductsClaudeClaudeClaudeClaude CodeClaude CodeClaude CodeCoworkCoworkCoworkMax planMax planMax planTeam planTeam planTeam planEnterprise planEnterprise planEnterprise planDownload appDownload appDownload appPricingPricingPricingLog inLog inLog inFeaturesClaude in ChromeClaude in ChromeClaude in ChromeClaude in SlackClaude in SlackClaude in SlackClaude in ExcelClaude in ExcelClaude in ExcelSkillsSkillsSkillsModelsOpusOpusOpusSonnetSonnetSonnetHaikuHaikuHaikuSolutionsAI agentsAI agentsAI agentsCode modernizationCode modernizationCode modernizationCodingCodingCodingCustomer supportCustomer supportCustomer supportEducationEducationEducationFinancial servicesFinancial servicesFinancial servicesGovernmentGovernmentGovernmentHealthcareHealthcareHealthcareLife sciencesLife sciencesLife sciencesNonprofitsNonprofitsNonprofitsClaude Developer PlatformOverviewOverviewOverviewDeveloper docsDeveloper docsDeveloper docsPricingPricingPricingRegional ComplianceRegional ComplianceRegional ComplianceAmazon BedrockAmazon BedrockAmazon BedrockGoogle Cloud’s Vertex AIGoogle Cloud’s Vertex AIGoogle Cloud’s Vertex AIConsole loginConsole loginConsole loginLearnBlogBlogBlogClaude partner networkClaude partner networkClaude partner networkCoursesCoursesCoursesConnectorsConnectorsConnectorsCustomer storiesCustomer storiesCustomer storiesEngineering at AnthropicEngineering at AnthropicEngineering at AnthropicEventsEventsEventsPluginsPluginsPluginsPowered by ClaudePowered by ClaudePowered by ClaudeService partnersService partnersService partnersStartups programStartups programStartups programTutorialsTutorialsTutorialsUse casesUse casesUse casesCompanyAnthropicAnthropicAnthropicCareersCareersCareersEconomic FuturesEconomic FuturesEconomic FuturesResearchResearchResearchNewsNewsNewsResponsible Scaling PolicyResponsible Scaling PolicyResponsible Scaling PolicySecurity and complianceSecurity and complianceSecurity and complianceTransparencyTransparencyTransparencyHelp and securityAvailabilityAvailabilityAvailabilityStatusStatusStatusSupport centerSupport centerSupport centerTerms and policiesPrivacy choices
 /* Dialog styling */
 dialog#consent-container {
 margin: 0;
 padding: 8px;
 opacity: 0;
 transform: translateY(16px);
 transition: opacity 0.3s ease-out, transform 0.3s ease-out;
 }

 dialog#consent-container.show {
 opacity: 1;
 transform: translateY(0);
 }

 dialog#consent-container::backdrop {
 background: transparent;
 }

 dialog button span {
 display: inline !important;
 }

 /* Toggle switch styling */
 .toggle_switch {
 position: relative;
 display: inline-block;
 width: 36px;
 height: 24px;
 }

 .toggle_switch input {
 opacity: 0;
 width: 0;
 height: 0;
 }

 .toggle_slider {
 position: absolute;
 cursor: pointer;
 top: 0;
 left: 0;
 right: 0;
 bottom: 0;
 background-color: #87867f;
 transition: .4s;
 border-radius: 24px;
 }

 .toggle_slider:before {
 position: absolute;
 content: "";
 height: 18px;
 width: 18px;
 left: 3px;
 bottom: 3px;
 background-color: white;
 transition: .4s;
 border-radius: 50%;
 }

 input:checked + .toggle_slider {
 background-color: #d97757;
 }

 input:checked + .toggle_slider:before {
 transform: translateX(12px);
 }

 input:disabled + .toggle_slider {
 cursor: not-allowed;
 opacity: 0.5;
 }

 @media only screen and (max-width: 501px) {
 dialog#consent-container {
 left: 8px !important;
 bottom: 8px !important;
 right: 8px !important;
 }
 #consent-banner {
 padding: 24px 16px 16px !important;
 }
 #simple-options {
 grid-template-columns: repeat(3, 1fr) !important;
 grid-template-rows: auto auto !important;
 }
 #customize-btn {
 grid-column: span 1 !important;
 }
 dialog button span {
 display: none !important;
 }

 
 Cookie settings
 
 We use cookies to deliver and improve our services, analyze site usage, and if you agree, to customize or personalize your experience and market our services to you. You can read our Cookie Policy here.
 

 Customize cookie settings
 
 
 Reject all cookies
 
 
 Accept all cookies
 
 
 Necessary
 Enables security and basic functionality.
 
 
 Required
 
 
 Analytics
 Enables tracking of site performance.
 
 
 Off
 
 
 Marketing
 Enables ads personalization and tracking.
 
 
 Off
 
 
 Save preferences
 
 
Privacy policyPrivacy policyPrivacy policyResponsible disclosure policyResponsible disclosure policyResponsible disclosure policyTerms of service: CommercialTerms of service: CommercialTerms of service: CommercialTerms of service: ConsumerTerms of service: ConsumerTerms of service: ConsumerUsage policyUsage policyUsage policyx.comx.comLinkedInLinkedInYouTubeYouTubeInstagramInstagramEnglish (US)

 function initDynamicCurrentYear() { 
 const currentYear = new Date().getFullYear();
 const currentYearElements = document.querySelectorAll('[data-current-year]');
 currentYearElements.forEach(currentYearElement => {
 currentYearElement.textContent = currentYear;
 });
 }

 // Initialize Dynamic Current Year
 document.addEventListener('DOMContentLoaded', () => {
 initDynamicCurrentYear();
 });
gsap.registerPlugin(ScrollTrigger,SplitText,TextPlugin,Flip,Draggable,InertiaPlugin);

 document.addEventListener('DOMContentLoaded', function() {
 const contentElement = document.querySelector('[data-readtime="content"]');
 const minutesElement = document.querySelector('[data-readtime="minutes"]');

 if (!contentElement || !minutesElement) return;

 const text = contentElement.innerText || contentElement.textContent;
 const wordCount = text.trim().split(/\s+/).length;
 const wordsPerMinute = 250;
 const minutes = Math.round(wordCount / wordsPerMinute);

 minutesElement.textContent = minutes || 1; // minimum 1 minute
 });
 
 // Hide all empty paragraph tags from the main content RTF
 document.querySelectorAll('#tutorial_content p').forEach(p => {
 if (p.textContent.trim() === '' || /^[\u200B-\u200D\uFEFF]+$/.test(p.textContent)) {
 p.remove();
 }
 });

 
 ×


---
## resources-tutorials-getting-started-with-claude-in-excel.md

<!-- Source: https://claude.com/resources/tutorials/getting-started-with-claude-in-excel -->

:root {
 --grid-breakout: [full-start] minmax(0, 1fr) [content-start] repeat(var(--_grid---column-count), minmax(0, var(--_grid---column-width))) [content-end] minmax(0, 1fr) [full-end];
 --grid-breakout-single: [full-start] minmax(0, 1fr) [content-start] minmax(0, calc(100% - var(--site--margin) * 2)) [content-end] minmax(0, 1fr) [full-end];
 }
 ::before, ::after {
 box-sizing: border-box;
 }
 .w-embed:before, .w-embed:after,
 .w-richtext:before, .w-richtext:after {
 content: unset;
 }
 html {
 background-color: var(--_theme---background);
 }
 button {
 background-color: unset;
 padding: unset;
 text-align: inherit;
 }
 button:not(:disabled) {
 cursor: pointer;
 }
 video {
 width: 100%;
 object-fit: cover;
 }
 /* remove padding of empty element */
 .wf-empty {
 padding: 0;
 }
 svg {
 max-width: 100%;
 }
 @media (prefers-color-scheme: light) {
 option { color: black; }
 }
 img::selection {
 background: transparent;
 }
 /* Typography */
 body {
 text-transform: var(--_text-style---text-transform);
 font-smoothing: antialiased;
 -webkit-font-smoothing: antialiased;
 }

 /* Clear Defaults */
 a:not ([class]) {
 text-decoration: underline;} 

 [class~="u-rich-text"] a,
 [class~="u-rich-text-cs"] a,
 [class~="u-rich-text-blog"] a,
 [class~="u-rich-text-tutorials"] a,
 a.u-rich-text,
 [class~="command_instruction"] a {
 transition: color .15s ease-out, text-decoration-color .15s ease-out;
 text-underline-offset: 3px;
 text-decoration: underline;
 color: currentcolor;
 text-decoration-color: var(--_theme---border-primary);
 }

 [class~="u-rich-text"] a:hover,
 [class~="u-rich-text-cs"] a:hover,
 [class~="u-rich-text-blog"] a:hover,
 [class~="u-rich-text-tutorials"] a:hover,
 a.u-rich-text:hover,
 [class~="command_instruction"] a:hover {
 text-decoration-color: var(--_theme---foreground-primary);
 color: var(--_theme---foreground-primary);
 }

 h1,h2,h3,h4,h5,h6,p,blockquote,label {
 font-family: inherit;
 font-size: inherit;
 font-weight: inherit;
 line-height: inherit;
 letter-spacing: inherit;
 text-transform: inherit;
 text-wrap: inherit;
 margin-top: 0;
 margin-bottom: 0;
 }
 select:has(option[value=""]:checked) {
 color: color-mix(in lab, currentcolor 60%, transparent)
 }
 /* Selection Color */
 ::selection {
 background-color: var(--_theme---selection--background);
 color: var(--_theme---selection--text);
 }
 /* Margin Trim */
 :is(.u-margin-trim,.u-rich-text) > :not(:not(.w-condition-invisible,.u-cover-absolute,.u-ignore-trim) ~ :not(.w-condition-invisible,.u-cover-absolute,.u-ignore-trim)),
 :is(.u-margin-trim,.u-rich-text) > :not(:not(.w-condition-invisible,.u-cover-absolute,.u-ignore-trim) ~ :not(.w-condition-invisible,.u-cover-absolute,.u-ignore-trim)).u-display-contents > :first-child {
 margin-top: 0;
 }
 :is(.u-margin-trim,.u-rich-text) > :not(:has(~ :not(.w-condition-invisible,.u-cover-absolute,.u-ignore-trim))),
 :is(.u-margin-trim,.u-rich-text) > :not(:has(~ :not(.w-condition-invisible,.u-cover-absolute,.u-ignore-trim))).u-display-contents > :last-child {
 margin-bottom: 0;
 }
 /* Line Height Trim */
 :is(h1,h2,h3,h4,h5,h6,p):not(.u-text-trim-off,:has([class*="u-text-style-"]))::before,
 [class*="u-text-style-"]:not(.u-text-trim-off,:has(h1,h2,h3,h4,h5,h6,p))::before {
 content: "";
 display: table;
 margin-bottom: calc(-0.5lh + var(--_text-style---trim-top));
 }
 :is(h1,h2,h3,h4,h5,h6,p):not(.u-text-trim-off,:has([class*="u-text-style-"]))::after,
 [class*="u-text-style-"]:not(.u-text-trim-off,:has(h1,h2,h3,h4,h5,h6,p))::after {
 content: "";
 display: table;
 margin-bottom: calc(-0.5lh + var(--_text-style---trim-bottom));
 }
 /* Rich Text Links */
 .w-richtext a {
 position: relative;
 z-index: 4;
 }
 /* Line Clamp */
 .u-line-clamp-1, .u-line-clamp-2, .u-line-clamp-3, .u-line-clamp-4 {
 -webkit-line-clamp: 1;
 -webkit-box-orient: vertical;
 }
 .u-line-clamp-2 { -webkit-line-clamp: 2; }
 .u-line-clamp-3 { -webkit-line-clamp: 3; }
 .u-line-clamp-4 { -webkit-line-clamp: 4; }
 /* Child Contain */
 .u-child-contain > * {
 width: 100%;
 max-width: inherit !important;
 margin-inline: 0 !important;
 margin-top: 0 !important;
 }
 /* Hide */
 .u-hide-if-empty:empty,
 .u-hide-if-empty:not(:has(> :not(.w-condition-invisible))),
 .u-hide-if-empty-cms:not(:has(.w-dyn-item)),
 .u-embed-js,
 .u-embed-css {
 display: none !important;
 }
 /* Focus State */
 a, button, :where([tabindex]), [data-outline] {
 outline-offset: var(--focus--offset-outer);
 }
 a:focus-visible,
 button:focus-visible,
 [tabindex]:focus-visible,
 label:has(input:focus-visible) [data-outline] {
 outline-color: color-mix(in srgb, var(--_button-style---border) 50%, transparent);
 outline-width: var(--focus--width);
 outline-style: solid;
 }

 /* Global / Clickable Component */
 .wf-design-mode .clickable_wrap {
 z-index: 0;
 }
 .clickable_wrap a[href="#"] {
 display: none;
 }
 .clickable_wrap a[href="#"] ~ button {
 display: block;
 }
 /* Responsive Above */
 @container threshold-large (width >= 62em) {
 .u-order-unset-above { order: unset !important; }
 .u-all-unset-above { all: unset !important; }
 .u-grid-below { display: flex !important; }
 .u-max-width-unset-above { max-width: unset !important; }
 .u-width-unset-above { width: unset !important; }
 .u-hide-above { display: none !important; }
 }
 @container threshold-medium (width >= 48em) {
 .u-order-unset-above { order: unset !important; }
 .u-all-unset-above { all: unset !important; }
 .u-grid-below { display: flex !important; }
 .u-max-width-unset-above { max-width: unset !important; }
 .u-width-unset-above { width: unset !important; }
 .u-hide-above { display: none !important; }
 }
 @container threshold-small (width >= 30em) {
 .u-order-unset-above { order: unset !important; }
 .u-all-unset-above { all: unset !important; }
 .u-grid-below { display: flex !important; }
 .u-max-width-unset-above { max-width: unset !important; }
 .u-width-unset-above { width: unset !important; }
 .u-hide-above { display: none !important; }
 }
 /* Responsive Below */
 @container threshold-large (width < 62em) {
 .u-order-unset-below { order: unset !important; }
 .u-all-unset-below { all: unset !important; }
 .u-grid-above { display: flex !important; }
 .u-max-width-unset-below { max-width: unset !important; }
 .u-width-unset-below { width: unset !important; }
 .u-alignment-unset-below {
 --_alignment---direction: start;
 align-self: start;
 }
 .u-hide-below { display: none !important; }
 }
 @container threshold-medium (width < 48em) {
 .u-order-unset-below { order: unset !important; }
 .u-all-unset-below { all: unset !important; }
 .u-grid-above { display: flex !important; }
 .u-max-width-unset-below { max-width: unset !important; }
 .u-width-unset-below { width: unset !important; }
 .u-alignment-unset-below {
 --_alignment---direction: start;
 align-self: start;
 }
 .u-hide-below { display: none !important; }
 }
 @container threshold-small (width < 30em) {
 .u-order-unset-below { order: unset !important; }
 .u-all-unset-below { all: unset !important; }
 .u-grid-above { display: flex !important; }
 .u-max-width-unset-below { max-width: unset !important; }
 .u-width-unset-below { width: unset !important; }
 .u-alignment-unset-below {
 --_alignment---direction: start;
 align-self: start;
 }
 .u-hide-below { display: none !important; }
 }
 /* Form Radio */
 .form_main_radio_label:has(input:checked) .form_main_radio_circle_inner {
 opacity: 1;
 }
 /* Form Checkbox */
 .form_main_checkbox_label:has(input:checked) .form_main_checkbox_box {
 background-color: currentColor;
 border-color: currentColor;
 }
 .form_main_checkbox_label:has(input:checked) .form_main_checkbox_icon {
 opacity: 1;
 }
 /* State Manager */
 [data-state] { --_state---true: 1; --_state---false: 0; }
 .is-active,
 [data-state~="checked"]:is(:checked, :has(:checked)),
 [data-state~="current"]:is(.w--current, :has(.w--current)),
 [data-state~="open"]:is(.w--open, :has(.w--open)),
 [data-state~="expanded"]:is([aria-expanded="true"], :has([aria-expanded="true"])),
 [data-state~="external"]:is([target="_blank"], :has([target="_blank"])) { 
 --_state---true: 0; --_state---false: 1;
 }
 .wf-design-mode [data-trigger~="preview"],
 [data-trigger~="focus"]:is(:focus-visible, :has(:focus-visible)),
 [data-trigger~="group"]:has([data-trigger~="focus-other"]:focus-visible, [data-trigger~="focus-other"] :focus-visible)
 [data-trigger~="focus-other"]:not(:focus-visible, :has(:focus-visible)) {
 --_trigger---on: 0; --_trigger---off: 1;
 }
 @media (hover: hover) {
 [data-button]:hover,
 [data-trigger~="hover"]:is(a:hover,button:hover,:has(a:hover,button:hover)),
 [data-trigger~="group"]:has([data-trigger~="hover-other"]:hover) [data-trigger~="hover-other"]:not(:hover) { 
 --_trigger---on: 0; --_trigger---off: 1;
 }
 [data-trigger~="hover-other"]:hover { --_trigger---on: 1 !important; --_trigger---off: 0 !important; }
 }
 @media (hover: none) {
 [data-trigger~="mobile"] { --_trigger---on: 0; --_trigger---off: 1; }
 }

 code, kbd, pre, samp {
 font-family: var(--_typography---font--mono-family);
 }
 body * {
 scrollbar-width: none; /* Firefox */
 -ms-overflow-style: none; /* IE/Edge Legacy */
 }
 body *::-webkit-scrollbar {
 display: none; /* Unreliable */
 width: 0px; /* WebKit/Blink */
 }

 @media (prefers-color-scheme: dark) {
 body,
 .u-theme-ivory,
 [data-wf--section--theme="ivory"] {
 --_theme---background-primary: var(--swatch--gray-950);
 --_theme---background-secondary: var(--swatch--gray-900);
 --_theme---background-tertiary: var(--swatch--gray-850);
 --_theme---border-primary: var(--swatch--gray-600);
 --_theme---border-secondary: var(--swatch--gray-700);
 --_theme---border-tertiary: var(--swatch--gray-750);
 --_theme---foreground-primary: var(--swatch--gray-050);
 --_theme---foreground-secondary: var(--swatch--gray-400);
 --_theme---foreground-tertiary: var(--swatch--gray-500);
 --_theme---pictogram-accent: var(--swatch--gray-750);
 --_theme---button-primary--background: var(--swatch--gray-050);
 --_theme---button-primary--text: var(--swatch--gray-950);
 --_theme---button-primary--border: var(--swatch--transparent);
 --_theme---button-primary--icon: var(--_theme---button-primary--text);
 --_theme---button-primary--background-hover: var(--_theme---button-primary--background);
 --_theme---button-primary--text-hover: var(--_theme---button-primary--text);
 --_theme---button-primary--border-hover: var(--_theme---button-primary--border);
 --_theme---button-primary--icon-hover: var(--_theme---background-primary);
 --_theme---button-secondary--background: var(--swatch--gray-750);
 --_theme---button-secondary--text: var(--swatch--gray-050);
 --_theme---button-secondary--border: var(--_theme---border-secondary);
 --_theme---button-secondary--icon: var(--_theme---button-secondary--text);
 --_theme---button-secondary--background-hover: var(--_theme---button-secondary--background);
 --_theme---button-secondary--text-hover: var(--_theme---button-secondary--text);
 --_theme---button-secondary--border-hover: var(--_theme---button-secondary--background);
 --_theme---button-secondary--icon-hover: var(--_theme---foreground-secondary);
 --_theme---button-tertiary--background: var(--_theme---background-primary);
 --_theme---button-tertiary--text: var(--swatch--gray-050);
 --_theme---button-tertiary--border: var(--_theme---border-secondary);
 --_theme---button-tertiary--icon: var(--_theme---button-tertiary--text);
 --_theme---button-tertiary--background-hover: var(--_theme---button-tertiary--background);
 --_theme---button-tertiary--text-hover: var(--_theme---button-tertiary--text);
 --_theme---button-tertiary--border-hover: var(--_theme---button-tertiary--border);
 --_theme---button-tertiary--icon-hover: var(--_theme---foreground-primary);
 --_theme---error-text: #df6666;
 --_theme---heroes-accent: #C46849;
 --_theme---white: var(--_theme---background-primary);
 }
 .u-theme-white,
 [data-wf--section--theme="white"] {
 --_theme---background-primary: var(--swatch--gray-850);
 --_theme---background-secondary: var(--swatch--gray-800);
 --_theme---background-tertiary: var(--swatch--gray-750);
 --_theme---border-primary: var(--swatch--gray-550);
 --_theme---border-secondary: var(--swatch--gray-650);
 --_theme---border-tertiary: var(--swatch--gray-700);
 --_theme---foreground-primary: var(--swatch--gray-050);
 --_theme---foreground-secondary: var(--swatch--gray-350);
 --_theme---foreground-tertiary: var(--swatch--gray-450);
 --_theme---pictogram-accent: var(--swatch--gray-700);
 --_theme---button-primary--background: var(--swatch--gray-050);
 --_theme---button-primary--text: var(--swatch--gray-950);
 --_theme---button-primary--border: var(--swatch--transparent);
 --_theme---button-primary--icon: var(--_theme---button-primary--text);
 --_theme---button-primary--background-hover: var(--_theme---button-primary--background);
 --_theme---button-primary--text-hover: var(--_theme---button-primary--text);
 --_theme---button-primary--border-hover: var(--_theme---button-primary--border);
 --_theme---button-primary--icon-hover: var(--_theme---background-primary);
 --_theme---button-secondary--background: var(--swatch--gray-700);
 --_theme---button-secondary--text: var(--swatch--gray-050);
 --_theme---button-secondary--border: var(--_theme---border-secondary);
 --_theme---button-secondary--icon: var(--_theme---button-secondary--text);
 --_theme---button-secondary--background-hover: var(--_theme---button-secondary--background);
 --_theme---button-secondary--text-hover: var(--_theme---button-secondary--text);
 --_theme---button-secondary--border-hover: var(--_theme---button-secondary--background);
 --_theme---button-secondary--icon-hover: var(--_theme---foreground-secondary);
 --_theme---button-tertiary--background: var(--_theme---background-primary);
 --_theme---button-tertiary--text: var(--swatch--gray-050);
 --_theme---button-tertiary--border: var(--_theme---border-secondary);
 --_theme---button-tertiary--icon: var(--_theme---button-tertiary--text);
 --_theme---button-tertiary--background-hover: var(--_theme---button-tertiary--background);
 --_theme---button-tertiary--text-hover: var(--_theme---button-tertiary--text);
 --_theme---button-tertiary--border-hover: var(--_theme---button-tertiary--border);
 --_theme---button-tertiary--icon-hover: var(--_theme---foreground-primary);
 --_theme---error-text: #df6666;
 --_theme---heroes-accent: #C46849;
 --_theme---white: var(--_theme---background-primary);
 }
 .u-theme-neutral-1,
 [data-wf--section--theme="neutral-1"] {
 --_theme---background-primary: var(--swatch--gray-800);
 --_theme---background-secondary: var(--swatch--gray-750);
 --_theme---background-tertiary: var(--swatch--gray-700);
 --_theme---border-primary: var(--swatch--gray-500);
 --_theme---border-secondary: var(--swatch--gray-600);
 --_theme---border-tertiary: var(--swatch--gray-650);
 --_theme---foreground-primary: var(--swatch--gray-050);
 --_theme---foreground-secondary: var(--swatch--gray-300);
 --_theme---foreground-tertiary: var(--swatch--gray-400);
 --_theme---pictogram-accent: var(--swatch--gray-650);
 --_theme---button-primary--background: var(--swatch--gray-050);
 --_theme---button-primary--text: var(--swatch--gray-950);
 --_theme---button-primary--border: var(--swatch--transparent);
 --_theme---button-primary--icon: var(--_theme---button-primary--text);
 --_theme---button-primary--background-hover: var(--_theme---button-primary--background);
 --_theme---button-primary--text-hover: var(--_theme---button-primary--text);
 --_theme---button-primary--border-hover: var(--_theme---button-primary--border);
 --_theme---button-primary--icon-hover: var(--_theme---background-primary);
 --_theme---button-secondary--background: var(--swatch--gray-650);
 --_theme---button-secondary--text: var(--swatch--gray-050);
 --_theme---button-secondary--border: var(--_theme---border-secondary);
 --_theme---button-secondary--icon: var(--_theme---button-secondary--text);
 --_theme---button-secondary--background-hover: var(--_theme---button-secondary--background);
 --_theme---button-secondary--text-hover: var(--_theme---button-secondary--text);
 --_theme---button-secondary--border-hover: var(--_theme---button-secondary--background);
 --_theme---button-secondary--icon-hover: var(--_theme---foreground-secondary);
 --_theme---button-tertiary--background: var(--_theme---background-primary);
 --_theme---button-tertiary--text: var(--swatch--gray-050);
 --_theme---button-tertiary--border: var(--_theme---border-secondary);
 --_theme---button-tertiary--icon: var(--_theme---button-tertiary--text);
 --_theme---button-tertiary--background-hover: var(--_theme---button-tertiary--background);
 --_theme---button-tertiary--text-hover: var(--_theme---button-tertiary--text);
 --_theme---button-tertiary--border-hover: var(--_theme---button-tertiary--border);
 --_theme---button-tertiary--icon-hover: var(--_theme---foreground-primary);
 --_theme---error-text: #df6666;
 --_theme---heroes-accent: #C46849;
 --_theme---white: var(--_theme---background-primary);
 }

 .logo_light {
 display: none;
 }
 .logo_dark {
 display: block;
 }
 .illustration_light {
 display: none;
 }
 .illustration_dark {
 display: block;
 }

 }

 @media (prefers-color-scheme: light) {
 .logo_light {
 display: block;
 }
 .logo_dark {
 display: none;
 }
 .illustration_light {
 display: block;
 }
 .illustration_dark {
 display: none;
 }
 }

 .u-text-font-mono {
 --_text-style---trim-top: var(--_typography---font--mono-text-trim-top);
 --_text-style---trim-bottom: var(--_typography---font--mono-text-trim-bottom);
 }

 .u-checklist ul {
 list-style: none;
 margin: 0;
 padding: 0;
 }

 .u-checklist ul li {
 position: relative; 
 padding-left: 2rem; 
 }

 .u-checklist ul li::before {
 content: ""; 
 position: absolute;
 left: 0;
 top: 0.1em;
 width: 1.5rem;
 height: 1.5rem;
 background-repeat: no-repeat;
 background-position: center;
 background-size: contain;
 background-image: url("data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20viewBox%3D%220%200%2024%2024%22%20fill%3D%22none%22%20xmlns%3D%22http%3A//www.w3.org/2000/svg%22%3E%3Cpath%20d%3D%22M18.226%206.13068C18.4439%205.95655%2018.7615%205.95361%2018.9842%206.13888C19.2067%206.32458%2019.2604%206.63728%2019.1283%206.88304L19.0604%206.98382L10.0602%2017.784C9.95233%2017.9133%209.7949%2017.9908%209.62665%2017.9984C9.45844%2018.0059%209.29454%2017.9429%209.17547%2017.8238L4.97541%2013.6237L4.89806%2013.53C4.7446%2013.2971%204.7705%2012.9802%204.97541%2012.7753C5.18032%2012.5704%205.49726%2012.5445%205.73011%2012.698L5.82386%2012.7753L9.55868%2016.5101L18.1393%206.21506L18.226%206.13068Z%22%20fill%3D%22%235E5D59%22/%3E%3C/svg%3E");
 }

 [class^="card_"][class$="_wrap"] .clickable_wrap.u-cover-absolute .clickable_link,
 [class^="card_"][class$="_wrap"] .clickable_wrap.u-cover-absolute .clickable_btn {
 outline-offset: var(--focus--offset-inner);
 }

 textarea[data-autogrow] {
 overflow-y: hidden;
 resize: none;
 height: 1.75rem; 
 min-height: 0; 
 }

 .btn_main_wrap::hover,
 .btn_small_wrap::hover,
 .btn_tiny_wrap::hover,
 .button_toggle_wrap::hover,
 .btn_icon_main_wrap::hover,
 .btn_icon_small_wrap::hover,
 .btn_icon_tiny_wrap::hover{
 transition: /* Transition to click/active */
 box-shadow ease-in-out 100ms, 
 background ease-in-out 100ms,
 color ease-in-out 50ms;
 }

 .btn_main_wrap::active,
 .btn_small_wrap::active,
 .btn_tiny_wrap::active,
 .button_toggle_wrap::active,
 .btn_icon_main_wrap::active,
 .btn_icon_small_wrap::active,
 .btn_icon_tiny_wrap::active{
 transition: /* Transition to click/active */
 box-shadow ease-in-out 50ms, 
 background ease-in-out 50ms,
 color ease-in-out 25ms;
 }

 .card_cs_grid_img img {
 max-width: 60%;
 max-height: 60%;
 }

 @container viewport (width < 30em) {
 [data-wf--grid--column-count="4"]:has(.card_feature_wrap) .c-grid {
 --_column-count---value: 1;
 }
 }
 @container viewport (min-width: 30em) and (max-width: 62em) {
 [data-wf--grid--column-count="4"]:has(.card_feature_wrap) .c-grid {
 --_column-count---value: 2;
 }
 }

 /* Mods for spacing and visibility of embed in accordian content used for schema */
 .accordion_content_text p:has(+ .w-embed.w-script) {
 margin-bottom: 0;
 }

 /* Absolute inner SVG of lottie to prevent page jump */
 .heroes_lottie_component svg {
 position: absolute;
 top: 0;
 left: 0;
 }

 /* Sticky scroll */
 @media screen and (min-width: 992px) {
 .sticky_image_link_wrap:has(.sticky_image_link.w--current) {
 opacity: 1;
 width: calc((100% - var(--_grid---gutter)) * (6 / 12));
 }
 }
 @media screen and (max-width: 767px) {
 .c-grid:last-child .sticky_image_block,
 .sticky_image_block:last-child {
 padding: 0;
 }
 .c-grid:last-child .sticky_image_wrap {
 margin-bottom: 0;
 }
 }

 #send, #threads, #get-help, #collaborate {
 display: block; /* or grid, flex - anything but contents */
 }

 /* Select text below clickable overlay */
 html.wf-design-mode .clickable_wrap {
 pointer-events: none;
 }

 document.addEventListener("DOMContentLoaded", function () {
 // ---------------- Config ----------------
 const EDGE_PADDING = 16; // >= 1rem from edges
 const OFFSET_Y = 10; // gap under trigger
 const DIM_OPACITY = 0.3;
 const DIM_EASE_MS = 350;
 const CLOSE_DELAY = 120;
 const isCoarse = () => matchMedia("(hover: none), (pointer: coarse)").matches;

 // ---------------- Bubble (single instance) ----------------
 function ensureBubble(){
 let el = document.querySelector(".tt-bubble");
 if (el) return el;
 el = document.createElement("div");
 el.className = "tt-bubble u-theme-white";
 el.setAttribute("role","tooltip");
 el.setAttribute("aria-hidden","true");
 el.style.left = "0px";
 el.style.top = "0px";
 el.innerHTML = `
 <div class="tt-inner">
 <div class="tt-h" id="tt-title"></div>
 <p class="tt-b" id="tt-body"></p>
 <button type="button" class="tt-close" aria-label="Close">×</button>
 </div>`;
 document.body.appendChild(el);
 return el;
 }
 const bubble = ensureBubble();
 const elH = bubble.querySelector("#tt-title");
 const elB = bubble.querySelector("#tt-body");
 const elClose = bubble.querySelector(".tt-close");

 // ---------------- Parse [[term|heading|body]] anywhere ----------------
 const TOKEN_RE = /\[\[([^|\]]+)\|([^|\]]+)\|([^\]]+)\]\]/g;
 const BLOCK_SKIP = new Set(["SCRIPT","STYLE","NOSCRIPT","TEXTAREA","INPUT","SELECT","CODE","PRE","TEMPLATE","IFRAME"]);
 function shouldSkipTextNode(n){
 let el = n.parentElement;
 while (el){
 if (BLOCK_SKIP.has(el.tagName) || el.isContentEditable) return true;
 el = el.parentElement;
 }
 return false;
 }
 const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT);
 const textNodes = [];
 while (walker.nextNode()){
 const n = walker.currentNode;
 if (!n.nodeValue || shouldSkipTextNode(n)) continue;
 if (TOKEN_RE.test(n.nodeValue)) textNodes.push(n);
 TOKEN_RE.lastIndex = 0;
 }
 textNodes.forEach(node => {
 const frag = document.createDocumentFragment();
 const insideLink = !!node.parentElement.closest("a");
 let text = node.nodeValue, last = 0; TOKEN_RE.lastIndex = 0; let m;
 while ((m = TOKEN_RE.exec(text))){
 if (m.index > last) frag.appendChild(document.createTextNode(text.slice(last, m.index)));
 const term=m[1].trim(), heading=m[2].trim(), body=m[3].trim();
 const t = insideLink ? document.createElement("span") : document.createElement("button");
 if (insideLink){ t.setAttribute("role","button"); t.setAttribute("tabindex","0"); } else { t.type="button"; }
 t.className="tt-trigger";
 t.textContent=term;
 t.setAttribute("data-tt-h", heading);
 t.setAttribute("data-tt-b", body);
 t.setAttribute("aria-haspopup","dialog");
 t.setAttribute("aria-expanded","false");
 frag.appendChild(t);
 last = TOKEN_RE.lastIndex;
 }
 if (last < text.length) frag.appendChild(document.createTextNode(text.slice(last)));
 node.parentNode.replaceChild(frag, node);
 });

 // ---------------- State ----------------
 let current = null;
 let hoverCount = 0;
 let closeTimer = null;

 // Dimming bookkeeping
 let dimCtx = null; // { container, dimEls:[], wrappedTexts:[], pathEls:[] }

 // ---------------- Find the correct "text element" container ----------------
 function findTextContainer(trigger){
 // Prefer common RTE wrappers
 let el = trigger.closest(".w-richtext, .rich-text, .rte, [data-rte]");
 if (el) return el;

 // Otherwise climb until we find an ancestor that contains multiple block nodes anywhere inside.
 const BLOCK_SEL = "p,h1,h2,h3,h4,h5,h6,ul,ol,li,blockquote,pre,figure,figcaption";
 el = trigger.parentElement;
 while (el && el !== document.body){
 const blockCount = el.querySelectorAll(BLOCK_SEL).length;
 if (blockCount >= 2) return el;
 el = el.parentElement;
 }

 // Fallback: nearest non-inline container
 el = trigger.parentElement || document.body;
 while (el && el !== document.body){
 const d = getComputedStyle(el).display;
 if (d !== "inline" && d !== "contents") return el;
 el = el.parentElement;
 }
 return document.body;
 }

 // Utility: child of `ancestor` that contains `target` (direct child)
 function directChildContaining(ancestor, target){
 for (const ch of ancestor.children){
 if (ch === target || ch.contains(target)) return ch;
 }
 return null;
 }

 function getElementTarget(e) {
 // If target is already an Element, use it
 if (e.target instanceof Element) return e.target;
 // Otherwise, walk the composed/path for the first Element
 const path = (typeof e.composedPath === 'function') ? e.composedPath() : [];
 for (const n of path) if (n instanceof Element) return n;
 return null;
 }

 // ---------------- Dim everything except the trigger branch (sibling branches only) ----------------
 function dimAllOtherBranches(container, trigger){
 undim(); // clear previous

 const dimEls = [];
 const wrappedTexts = [];
 const pathEls = [];

 // Build ELEMENT-only path [container -> ... -> trigger]
 const path = [];
 for (let el = trigger; el && el !== container; el = el.parentElement) path.push(el);
 path.push(container);
 path.reverse();

 // At each ancestor level, find the *direct* child that leads to the trigger
 for (let i = 0; i < path.length; i++){
 const anc = path[i];
 const branchChild = (i < path.length - 1) ? directChildContaining(anc, path[i+1]) : path[i]; // last step is the trigger itself

 // Fade element siblings (whole branches)
 for (const child of anc.children){
 if (child === branchChild) continue; // keep the path branch crisp
 // Never fade any element that is (or contains) the trigger
 if (child === trigger || child.contains(trigger)) continue;
 child.style.transition = `opacity ${DIM_EASE_MS}ms ease`;
 child.style.opacity = String(DIM_OPACITY);
 dimEls.push(child);
 }

 // Fade TEXT NODE siblings directly under this ancestor (outside branchChild)
 anc.childNodes.forEach(node => {
 if (node.nodeType !== 3) return; // text only
 if (!node.nodeValue || !node.nodeValue.trim()) return;
 // If this text node sits inside branchChild, skip
 if (branchChild && branchChild.contains && branchChild.contains(node)) return;
 const span = document.createElement("span");
 span.style.transition = `opacity ${DIM_EASE_MS}ms ease`;
 span.style.opacity = String(DIM_OPACITY);
 span.textContent = node.nodeValue;
 node.parentNode.replaceChild(span, node);
 wrappedTexts.push(span);
 });

 // Keep a reference to the path elements (so we can explicitly restore opacity if needed)
 if (anc && anc.nodeType === 1) pathEls.push(anc);
 }

 // Hard-guard: explicitly set opacity:1 on the entire path to neutralize any inherited fade
 pathEls.forEach(el => {
 el.style.opacity = "1";
 });

 dimCtx = { container, dimEls, wrappedTexts, pathEls };
 }

 function undim(){
 if (!dimCtx) return;
 const { dimEls, wrappedTexts, pathEls } = dimCtx;

 // Animate back
 dimEls.forEach(el => {
 el.style.transition = `opacity ${DIM_EASE_MS}ms ease`;
 el.style.opacity = "1";
 // remove inline style after the animation so we don't override site CSS
 setTimeout(() => { if (el) el.style.opacity = ""; }, DIM_EASE_MS + 50);
 });

 wrappedTexts.forEach(span => {
 span.style.transition = `opacity ${DIM_EASE_MS}ms ease`;
 span.style.opacity = "1";
 span.addEventListener("transitionend", () => {
 if (!span.parentNode) return;
 span.parentNode.replaceChild(document.createTextNode(span.textContent || ""), span);
 }, { once:true });
 });

 // Clear hard-guard on path
 pathEls.forEach(el => { if (el) el.style.opacity = ""; });

 dimCtx = null;
 }

 // ---------------- Positioning (centered, edge-aware, flip) ----------------
 function clamp(v,min,max){ return Math.max(min,Math.min(max,v)); }
 function measureBubbleForPlacement(){
 const wasOpen = bubble.classList.contains("is-open");
 if (!wasOpen){ bubble.style.visibility="hidden"; bubble.classList.add("is-open"); }
 const rect = bubble.getBoundingClientRect();
 if (!wasOpen){ bubble.classList.remove("is-open"); bubble.style.visibility=""; }
 return { w: rect.width, h: rect.height };
 }
 function placeAnchored(trigger){
 const vw=innerWidth, vh=innerHeight;
 const r = trigger.getBoundingClientRect();
 const { w, h } = measureBubbleForPlacement();

 let left = r.left + (r.width/2) - (w/2);
 left = clamp(left, EDGE_PADDING, Math.max(EDGE_PADDING, vw - EDGE_PADDING - w));

 const topBelow = r.bottom + OFFSET_Y;
 const spaceBelow = vh - topBelow - EDGE_PADDING;
 const placeBelow = spaceBelow >= h;
 let top = placeBelow ? topBelow : (r.top - h - OFFSET_Y);
 top = clamp(top, EDGE_PADDING, Math.max(EDGE_PADDING, vh - EDGE_PADDING - h));

 bubble.style.left = left + "px";
 bubble.style.top = top + "px";

 const br = bubble.getBoundingClientRect();
 if (br.bottom > vh - EDGE_PADDING){
 bubble.style.maxHeight = (vh - 2*EDGE_PADDING) + "px";
 bubble.style.overflowY = "auto";
 } else {
 bubble.style.maxHeight = "none";
 bubble.style.overflowY = "visible";
 }
 }

 // ---------------- Open / Close (place → fade/scale) ----------------
 function animateIn(){
 bubble.style.transition = "none";
 bubble.style.opacity = "0";
 bubble.style.transform = "scale(0.95)";
 void bubble.offsetWidth;
 bubble.style.transition = "opacity .18s ease, transform .18s ease";
 bubble.style.opacity = "1";
 bubble.style.transform = "scale(1)";
 }
 function animateOut(done){
 bubble.style.transition = "opacity .16s ease, transform .16s ease";
 bubble.style.opacity = "0";
 bubble.style.transform = "scale(0.95)";
 const end = () => { bubble.removeEventListener("transitionend", end); done && done(); };
 bubble.addEventListener("transitionend", end);
 setTimeout(end, 260);
 }

 function openFromTrigger(trigger){
 if (current && current !== trigger) forceClose();
 current = trigger;
 trigger.setAttribute("aria-expanded","true");

 elH.textContent = trigger.getAttribute("data-tt-h") || "";
 elB.textContent = trigger.getAttribute("data-tt-b") || "";

 bubble.classList.add("is-open");
 bubble.setAttribute("aria-hidden","false");

 placeAnchored(trigger);
 animateIn();

 const container = findTextContainer(trigger);
 dimAllOtherBranches(container, trigger);

 hoverCount = 0;
 cancelCloseTimer();
 }

 function forceClose(){
 if (!current) return;
 bubble.classList.remove("is-open");
 bubble.setAttribute("aria-hidden","true");
 current.setAttribute("aria-expanded","false");
 current = null;
 undim();
 hoverCount = 0;
 cancelCloseTimer();
 }

 function closeWithAnim(){
 if (!current) return;
 const t = current;
 animateOut(() => {
 bubble.classList.remove("is-open");
 bubble.setAttribute("aria-hidden","true");
 t.setAttribute("aria-expanded","false");
 current = null;
 undim();
 });
 }

 function scheduleClose(){
 cancelCloseTimer();
 closeTimer = setTimeout(() => {
 if (hoverCount <= 0 && !isCoarse()) closeWithAnim();
 }, CLOSE_DELAY);
 }
 function cancelCloseTimer(){ if (closeTimer){ clearTimeout(closeTimer); closeTimer = null; } }

 // ---------------- Hover-intent (desktop) ----------------
 function onZoneEnter(){ if (isCoarse()) return; hoverCount++; cancelCloseTimer(); }
 function onZoneLeave(){ if (isCoarse()) return; hoverCount = Math.max(0, hoverCount - 1); if (hoverCount === 0) scheduleClose(); }

 bubble.addEventListener("pointerenter", onZoneEnter, true);
 bubble.addEventListener("mouseenter", onZoneEnter, true);
 bubble.addEventListener("pointerleave", onZoneLeave, true);
 bubble.addEventListener("mouseleave", onZoneLeave, true);

 const handleEnter = (e) => {
 if (isCoarse()) return;
 const target = getElementTarget(e);
 if (!target) return;
 const t = target.closest(".tt-trigger");
 if (!t) return;
 onZoneEnter();
 if (!current || current !== t) openFromTrigger(t);
 };
 const handleLeave = (e) => {
 if (isCoarse()) return;
 const target = getElementTarget(e);
 if (!target) return;
 const t = target.closest(".tt-trigger");
 if (!t) return;
 onZoneLeave();
 };
 document.addEventListener("pointerenter", handleEnter, true);
 document.addEventListener("mouseenter", handleEnter, true);
 document.addEventListener("pointerleave", handleLeave, true);
 document.addEventListener("mouseleave", handleLeave, true);

 // ---------------- Keyboard ----------------
 document.addEventListener("focusin", (e) => {
 if (!e.target) return;
 const t = e.target.closest(".tt-trigger");
 if (t) openFromTrigger(t);
 });
 document.addEventListener("focusout", (e) => {
 if (!e.target) return;
 const t = e.target.closest(".tt-trigger");
 if (t && current === t) closeWithAnim();
 });

 // ---------------- Mobile / coarse ----------------
 document.addEventListener("pointerdown", (e) => {
 if (!isCoarse()) return;

 const t = e.target.closest(".tt-trigger");
 if (!t) return;
 e.preventDefault();
 e.stopPropagation();
 if (current === t && bubble.classList.contains("is-open")) { closeWithAnim(); return; }
 openFromTrigger(t);
 }, true);

 document.addEventListener("click", (e) => {
 if (!isCoarse()) return;
 if (!bubble.classList.contains("is-open")) return;
 const inBubble = !!e.target.closest(".tt-bubble");
 const onTrigger = !!e.target.closest(".tt-trigger");
 if (!inBubble && !onTrigger) closeWithAnim();
 }, true);

 // Close button + ESC
 elClose.addEventListener("click", closeWithAnim);
 document.addEventListener("keydown", (e) => { if (e.key === "Escape") closeWithAnim(); });

 // Reposition on resize/scroll while open
 const reposition = () => { if (!current) return; placeAnchored(current); };
 addEventListener("resize", reposition, { passive: true });
 addEventListener("scroll", reposition, { passive: true });
 });
 
/* Tooltip Styles */

 /* Trigger */
 .tt-trigger {
 cursor: help;
 text-decoration: underline dotted;
 text-underline-offset: .2em;
 color: inherit;
 }
 .tt-trigger:focus-visible{ outline:2px solid currentColor; outline-offset:2px; }

 /* Bubble */
 .tt-bubble{
 position: fixed;
 z-index: 10;
 max-width: 17rem;
 background: var(--_theme---background-primary);
 box-shadow: 0 4px 24px rgba(0,0,0,.05);
 border-radius: var(--radius--large);
 border-style: solid;
 border-color: var(--_theme---border-tertiary);
 padding: var(--_spacing---space--1-5rem);
 pointer-events: none;
 opacity: 0;
 transform: translate3d(0,0,0) scale(.98);
 transition: opacity .3s ease, transform .3s ease;
 will-change: transform, opacity;
 }
 .tt-bubble.is-open{ opacity:1; transform:translate3d(0,0,0) scale(1); pointer-events:auto; }

 .tt-h{ 
 margin-bottom: var(--_spacing---space--0-5rem); 
 font-size: var(--_typography---font-size--body-3); 
 font-family: var(--_typography---font--secondary-family);
 line-height: var(--_typography---line-height--1-6); 
 color: var(--_theme---foreground-primary);
 }
 .tt-b{ 
 margin:0; 
 font-size: var(--_typography---font-size--caption);
 line-height: var(--_typography---line-height--1-6);
 color: var(--_theme---foreground-tertiary);
 }

 /* Mobile close button */
 .tt-close {
 display: none;
 }
 @media (hover: none), (pointer: coarse) {
 .tt-close {
 display: inline-flex;
 position: absolute;
 top: 0.5rem;
 right: 0.5rem;
 width: 32px;
 height: 32px;
 align-items: center;
 justify-content: center;
 border: 0;
 border-radius: 999px;
 background: transparent;
 font-size: 22px; 
 line-height: 1;
 color: inherit;
 cursor: pointer;
 touch-action: manipulation;
 }
 .tt-close:focus-visible { outline: 2px solid currentColor; outline-offset: 2px; }
 .tt-close:hover { opacity: 1; }
 }

 html[lang="de-DE"] h1, html[lang="de-DE"] h2, html[lang="de-DE"] h3, 
 html[lang="de-DE"] h4, html[lang="de-DE"] h5, html[lang="de-DE"] h6,
 html[lang="de-DE"] p, html[lang="de-DE"] li,
 html[lang="fr-FR"] h1, html[lang="fr-FR"] h2, html[lang="fr-FR"] h3,
 html[lang="fr-FR"] h4, html[lang="fr-FR"] h5, html[lang="fr-FR"] h6,
 html[lang="fr-FR"] p, html[lang="fr-FR"] li {
 overflow-wrap: break-word;
 hyphens: auto;
 }

 :root {
 --nav--icon-thickness: var(--border-width--main);
 --nav--hamburger-thickness: var(--nav--icon-thickness);
 --nav--hamburger-gap: var(--_spacing---space--0-25rem);
 --nav--hamburger-rotate: 45;
 --nav--dropdown-duration: 300ms;
 --nav--dropdown-open-duration: 600ms;
 --nav--dropdown-delay: 0ms;
 --ease-expo-out: cubic-bezier(0.16, 1, 0.3, 1);
 }

 /* ========== GENERAL RESPONSIVE RULES ========== */

 /* Lock body when nav is open (script toggles .is-nav-open) */
 @media (width < 56em) {
 body.is-nav-open { overflow: hidden; }
 }

 @container (min-width: 56em) {
 .nav_wrap.is-desktop { display: block; }
 .nav_wrap.is-mobile { display: none; }
 }
 @container (width < 28em) {
 .nav_mobile_layout .nav_actions_mobile { display: none; }
 }

 /* ========== DROPDOWN STYLING ========== */

 html:not(.wf-design-mode) .nav_dropdown_component > .w-dropdown-list {
 display: grid !important;
 grid-template-columns: minmax(0, 1fr);
 grid-template-rows: 0fr;
 transition:
 grid-template-rows var(--nav--dropdown-duration) var(--ease-expo-out),
 visibility 0s var(--nav--dropdown-duration),
 opacity var(--nav--dropdown-duration) var(--ease-expo-out);
 visibility: hidden;
 opacity: 0;
 }
 html:not(.wf-design-mode) .nav_dropdown_component > .w-dropdown-list.w--open {
 visibility: visible;
 opacity: 1;
 transition:
 grid-template-rows var(--nav--dropdown-duration) var(--ease-expo-out),
 visibility 0s 0s,
 opacity var(--nav--dropdown-duration) var(--ease-expo-out);
 }
 .nav_dropdown_component > .w-dropdown-list > * { overflow: hidden; }
 .nav_dropdown_component:has(> .w-dropdown-toggle[aria-expanded="true"]) > .w-dropdown-list {
 --nav--dropdown-duration: var(--nav--dropdown-open-duration);
 grid-template-rows: 1fr;
 }
 /*.nav_wrap.is-desktop:has(.nav_dropdown_component > .w-dropdown-toggle.w--open[aria-expanded="false"])
 .nav_dropdown_component:has(> .w--open[aria-expanded="true"]) > .w-dropdown-list {
 transition-delay: var(--nav--dropdown-duration);
 }*/

 /* Dropdown caret rotation */
 .nav_links_svg.is-desktop { transition: transform 750ms var(--ease-expo-out); }
 .w-dropdown-toggle[aria-expanded="true"] .nav_links_svg.is-desktop { transform: rotate(-180deg); }

 .nav_links_svg_line.is-2 { transition: transform 500ms var(--ease-expo-out); }
 .w-dropdown-toggle[aria-expanded="true"] .nav_links_svg_line.is-2 { transform: rotate(0deg); }

 /* open (replicates your original transforms) */
 .nav_btn_wrap[aria-expanded="true"] .nav_btn_line:nth-child(1),
 .nav_btn_wrap[aria-expanded="true"] > * > :first-child {
 transform:
 translateY(calc(var(--nav--hamburger-thickness) * 1 + var(--nav--hamburger-gap) * 1))
 rotate(calc(var(--nav--hamburger-rotate) * -1deg));
 }
 .nav_btn_wrap[aria-expanded="true"] .nav_btn_line:nth-child(2),
 .nav_btn_wrap[aria-expanded="true"] > * > :nth-child(2) {
 opacity: 0;
 }
 .nav_btn_wrap[aria-expanded="true"] .nav_btn_line:nth-child(3),
 .nav_btn_wrap[aria-expanded="true"] > * > :last-child {
 transform:
 translateY(calc(var(--nav--hamburger-thickness) * -1 + var(--nav--hamburger-gap) * -1))
 rotate(calc(var(--nav--hamburger-rotate) * 1deg));
 width: 1rem;
 }

 /* ========== HOVER & THEME EFFECTS ========== */
 @media (hover: hover) and (pointer: fine) {
 body:has(.nav_dropdown_item:hover) .nav_dropdown_item:not(:hover) > * > * {
 color: var(--_theme---foreground-tertiary);
 }
 .nav_dropdown_link {
 transition:
 background-color 300ms ease,
 color 300ms ease;
 }
 .nav_dropdown_item:hover .nav_dropdown_link {
 background: var(--_theme---background-tertiary);
 color: var(--_theme---foreground-primary);
 }
 .nav_secondary_wrap .nav_dropdown_item:hover .nav_dropdown_link {
 background: var(--_theme---background-tertiary);
 color: var(--_theme---foreground-primary);
 }
 .nav_wrap.is-mobile .nav_dropdown_item:hover .nav_dropdown_link {
 color: var(--_theme---foreground-primary);
 }
 .nav_links_text { transition: color 500ms var(--ease-expo-out); }
 .nav_links_svg {
 transition:
 transform 500ms var(--ease-expo-out),
 color 500ms var(--ease-expo-out);
 }
 .nav_links_item:hover .nav_links_text,
 .nav_links_item:hover .nav_links_svg { color: var(--_theme---foreground-primary); }
 }

 /* ========== LAYOUT / UTILITY (kept, de-Webflow’d) ========== */
 .nav_wrap.is-mobile [data-open-on-mobile] > .w-dropdown-toggle { display: none; }
 .nav_wrap.is-mobile [data-open-on-mobile] > .w-dropdown-list {
 visibility: visible;
 opacity: 1;
 display: block;
 grid-template-rows: 1fr;
 }
 .nav_buttons_item .button_main_wrap { width: 100%; min-width: max-content; }

 /* Optional: fade out mobile actions while open */
 .nav_actions_wrap { transition: opacity 500ms var(--ease-expo-out); }
 body.is-nav-open .nav_actions_mobile .nav_actions_wrap {
 opacity: 0;
 pointer-events: none;
 }

 .nav_links_item:first-child {
 border-top: none;
 }

 /* ========== Breadcrumbs ========== */
 .breadcrumb_text.is_linked[href="#"],
 .breadcrumb_text:has(+.breadcrumb_text.is_linked:not([href="#"])) {
 display: none;
 }
 .breadcrumb_text.is_linked:not([href="#"]) {
 display: block;
 }

document.addEventListener("DOMContentLoaded", function () {
 document.querySelectorAll(".nav_component").forEach((root) => {
 if (root.dataset.scriptInitialized) return;
 root.dataset.scriptInitialized = "true";

 if (!window.gsap) { console.error("GSAP not found"); return; }

 const btn = root.querySelector('.nav_btn_wrap');
 const menu = root.querySelector('.nav_menu_wrap');
 if (!btn || !menu) { console.warn('Missing .nav_btn_wrap or .nav_menu_wrap in', root); return; }

 // a11y setup (scoped)
 if (!btn.hasAttribute('type')) btn.setAttribute('type', 'button');
 if (!btn.hasAttribute('aria-expanded')) btn.setAttribute('aria-expanded', 'false');
 if (!menu.id) menu.id = 'primary-nav-' + Math.random().toString(36).slice(2);
 if (!btn.hasAttribute('aria-controls')) btn.setAttribute('aria-controls', menu.id);
 menu.setAttribute('aria-hidden', 'true');

 // targets (scoped)
 const items = Array.from(menu.querySelectorAll('.nav_links_item'));
 const actions = menu.querySelector('.nav_menu_actions_wrap');

 // feature detection
 const prefersReduced = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
 const canClipInset = !!(window.CSS && CSS.supports && (
 CSS.supports('clip-path','inset(0 0 100% 0)') || CSS.supports('-webkit-clip-path','inset(0 0 100% 0)')
 ));
 const useClip = canClipInset && !prefersReduced;

 // durations from CSS vars
 function readDur(varName, fallbackSec) {
 const v = getComputedStyle(document.documentElement).getPropertyValue(varName).trim();
 if (!v) return fallbackSec;
 if (v.endsWith('ms')) return parseFloat(v)/1000;
 if (v.endsWith('s')) return parseFloat(v);
 const n = parseFloat(v);
 return isNaN(n) ? fallbackSec : n;
 }
 const OPEN_DUR = readDur('--nav--menu-open-duration', 0.8);
 const CLOSE_DUR = readDur('--nav--menu-close-duration', 0.4);

 // state per component
 let isOpen = false;
 let current = null;

 function setMenuVisibleForAnim() {
 menu.style.display = 'flex'; // ensure it's shown before anim
 menu.removeAttribute('hidden');
 menu.setAttribute('aria-hidden', 'false');
 menu.style.willChange = useClip ? 'clip-path' : 'transform, opacity';
 }
 function clearMenuInline() {
 gsap.set(menu, { clearProps: 'clipPath,webkitClipPath,opacity,transform,willChange,pointerEvents' });
 }

 // OPEN
 function playOpen() {
 setMenuVisibleForAnim();
 menu.style.pointerEvents = 'none';
 document.body.classList.add('is-nav-open');
 btn.setAttribute('aria-expanded', 'true');

 if (useClip) {
 gsap.set(menu, { clipPath: 'inset(0 0 100% 0)', webkitClipPath: 'inset(0 0 100% 0)' });
 } else {
 gsap.set(menu, { yPercent: -2, opacity: 0 });
 }
 if (items.length) gsap.set(items, { y: 20, autoAlpha: 0 });
 if (actions) gsap.set(actions, { y: 20, autoAlpha: 0 });

 const tl = gsap.timeline({ defaults: { ease: 'power3.out' } });

 if (useClip) {
 tl.to(menu, {
 clipPath: 'inset(0 0 0% 0)',
 webkitClipPath: 'inset(0 0 0% 0)',
 duration: prefersReduced ? 0.01 : OPEN_DUR,
 ease: 'expo.out'
 }, 0);
 } else {
 tl.to(menu, { yPercent: 0, opacity: 1, duration: prefersReduced ? 0.01 : Math.min(OPEN_DUR, 0.36) }, 0.02);
 }

 if (items.length) {
 tl.to(items, { y: 0, autoAlpha: 1, stagger: prefersReduced ? 0 : 0.08, duration: prefersReduced ? 0.01 : 0.4 }, 0.10);
 }
 if (actions) {
 const base = 0.10 + (items.length ? items.length * (prefersReduced ? 0 : 0.08) : 0);
 tl.to(actions, { y: 0, autoAlpha: 1, duration: prefersReduced ? 0.01 : 0.4 }, base);
 }

 tl.add(() => { menu.style.pointerEvents = 'auto'; }, '>-0.1');

 // listeners (per open)
 document.addEventListener('keydown', onKeydown);
 menu.addEventListener('click', onMenuLinkClick);

 return tl;
 }

 // CLOSE (fade all together, then clip inset close)
 function playClose() {
 menu.style.pointerEvents = 'none';
 btn.setAttribute('aria-expanded', 'false');
 document.body.classList.remove('is-nav-open');

 const tl = gsap.timeline({ defaults: { ease: 'power3.out' } });

 const fadeTargets = items.concat(actions ? [actions] : []);
 if (fadeTargets.length) tl.to(fadeTargets, { autoAlpha: 0, y: 0, duration: prefersReduced ? 0.01 : 0.2 }, 0);

 if (useClip) {
 gsap.set(menu, { clipPath: 'inset(0 0 0% 0)', webkitClipPath: 'inset(0 0 0% 0)' });
 tl.to(menu, {
 clipPath: 'inset(0 0 100% 0)',
 webkitClipPath: 'inset(0 0 100% 0)',
 duration: prefersReduced ? 0.01 : CLOSE_DUR
 }, '>-0.02');
 } else {
 tl.to(menu, { yPercent: -2, opacity: 0, duration: prefersReduced ? 0.01 : Math.min(CLOSE_DUR, 0.28) }, '>-0.02');
 }

 tl.add(() => {
 menu.style.display = 'none';
 menu.setAttribute('aria-hidden', 'true');
 clearMenuInline();
 if (items.length) gsap.set(items, { clearProps: 'all' });
 if (actions) gsap.set(actions, { clearProps: 'all' });

 // remove listeners added on open
 document.removeEventListener('keydown', onKeydown);
 menu.removeEventListener('click', onMenuLinkClick);
 });

 return tl;
 }

 function openMenu() {
 if (isOpen) return;
 isOpen = true;
 if (current && current.isActive()) current.kill();
 current = playOpen();
 }
 function closeMenu() {
 if (!isOpen) return;
 isOpen = false;
 if (current && current.isActive()) current.kill();
 current = playClose();
 }

 function onKeydown(e){ if (e.key === 'Escape' && isOpen) { e.preventDefault(); closeMenu(); } }

 function onMenuLinkClick(e){
 const a = e.target.closest('a[href]');
 if (!a) return;
 const url = new URL(a.href, location.href);
 if (url.origin === location.origin) {
 e.preventDefault();
 const tl = playClose();
 tl.eventCallback('onComplete', () => { window.location.href = a.href; });
 isOpen = false;
 }
 }

 // Toggle (scoped)
 btn.addEventListener('click', () => (isOpen ? closeMenu() : openMenu()));

 // Normalize if visible on load (scoped)
 if (getComputedStyle(menu).display !== 'none') {
 btn.setAttribute('aria-expanded', 'true');
 menu.setAttribute('aria-hidden', 'false');
 document.body.classList.add('is-nav-open');
 isOpen = true;
 }
 });
});

 (function () {
 'use strict';

 // ---------- tiny utils ----------
 var NS = 'navBundleInit';
 function onceFlag(el, k){ k=k||'scriptInitialized'; if (el.dataset[k]) return true; el.dataset[k]='true'; return false; }
 function ready(fn){ if(document.readyState==='loading'){document.addEventListener('DOMContentLoaded',fn,{once:true});} else { fn(); } }

 // ---------- 1) Ask Claude about this page ----------
 function initAskPage(){
 var buttons = document.querySelectorAll('[data-ask-page]');
 if (!buttons.length) return; // Early exit if no buttons

 buttons.forEach(function(btn){
 if (onceFlag(btn, NS)) return;
 btn.addEventListener('click', function (e) {
 e.preventDefault();
 var pageUrl = window.location.href;
 var prompt = "Read this page " + pageUrl + " so that I can ask you questions about it";
 var claudeUrl = new URL('https://claude.ai/new');
 claudeUrl.searchParams.set('q', prompt);
 window.open(claudeUrl.toString(), '_blank', 'noopener');
 });
 });
 }

 // ---------- 2) Copy page content as Markdown (Turndown) ----------
 var _turndownReady;
 function ensureTurndown(){
 if (window.TurndownService) return Promise.resolve();
 if (_turndownReady) return _turndownReady;
 _turndownReady = new Promise(function(resolve, reject){
 var s = document.createElement('script');
 s.src = 'https://unpkg.com/turndown/dist/turndown.js';
 s.async = true;
 s.onload = function(){ resolve(); };
 s.onerror = function(){ reject(new Error('Failed to load Turndown')); };
 document.head.appendChild(s);
 });
 return _turndownReady;
 }

 function initCopyAsMarkdown(){
 var copyButton = document.getElementById('copy-as-markdown');
 if (!copyButton) return; // Early exit

 if (onceFlag(copyButton, NS)) return;

 var buttonTextEl = copyButton.querySelector('.nav_dropdown_text') || copyButton;
 var originalText = buttonTextEl.textContent;

 copyButton.addEventListener('click', function(){
 ensureTurndown().then(function(){
 try {
 var TurndownService = window.TurndownService;
 var turndownService = new TurndownService({
 headingStyle: 'atx',
 codeBlockStyle: 'fenced',
 fence: '```',
 emDelimiter: '*',
 strongDelimiter: '**',
 linkStyle: 'inlined'
 });

 // Skip junk
 turndownService.addRule('skipWebflowElements', {
 filter: function(node){
 return node.nodeName === 'SCRIPT' ||
 node.nodeName === 'STYLE' ||
 (node.className && (String(node.className).includes('w-editor') || String(node.className).includes('w-embed')));
 },
 replacement: function(){ return ''; }
 });

 buttonTextEl.textContent = 'Copying...';
 copyButton.disabled = true;

 var contentElement = document.querySelector('main') ||
 document.querySelector('.main-content') ||
 document.querySelector('body');
 if (!contentElement) throw new Error('No content found to copy');

 var cloned = contentElement.cloneNode(true);
 cloned.querySelectorAll('script, style, nav, footer, .w-nav, .footer').forEach(function(el){ el.remove(); });

 var markdown = turndownService.turndown(cloned);

 var done = function(){
 buttonTextEl.textContent = 'Copied!';
 setTimeout(function(){
 buttonTextEl.textContent = originalText;
 copyButton.disabled = false;
 }, 2000);
 };

 if (navigator.clipboard && window.isSecureContext) {
 navigator.clipboard.writeText(markdown).then(done, function(err){ throw err; });
 } else {
 var ta = document.createElement('textarea');
 ta.value = markdown; ta.style.position='fixed'; ta.style.opacity='0';
 document.body.appendChild(ta); ta.select(); document.execCommand('copy'); document.body.removeChild(ta);
 done();
 }
 } catch (err){
 console.error('Copy failed:', err);
 buttonTextEl.textContent = 'Copy failed';
 setTimeout(function(){
 buttonTextEl.textContent = originalText;
 copyButton.disabled = false;
 }, 2000);
 }
 }).catch(function(err){
 console.error('Turndown load failed:', err);
 buttonTextEl.textContent = 'Copy failed';
 setTimeout(function(){
 buttonTextEl.textContent = originalText;
 copyButton.disabled = false;
 }, 2000);
 });
 });
 }

 // ---------- init all ----------
 ready(function(){
 initAskPage();
 initCopyAsMarkdown();
 });

 // Optional: expose minimal API for debugging (comment out in production if not needed)
 // window.NavBundle = {
 // initCopyAsMarkdown: initCopyAsMarkdown,
 // initAskPage: initAskPage
 // };
 })();
Explore here
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - 
THUMBNAIL BG COLORS
- - - - - - - - - - - - - - - - - - - - - - - - - - - - */
[data-thumbnail-bg="Clay"] { background-color: var(--swatch--clay); }
[data-thumbnail-bg="Cactus"] { background-color: var(--swatch--cactus); }
[data-thumbnail-bg="Coral"] { background-color: var(--swatch--coral); }
[data-thumbnail-bg="Fig"] { background-color: var(--swatch--fig); }
[data-thumbnail-bg="Heather"] { background-color: var(--swatch--heather); }
[data-thumbnail-bg="Oat"] { background-color: var(--swatch--oat); }
[data-thumbnail-bg="Olive"] { background-color: var(--swatch--olive); }
[data-thumbnail-bg="Sky"] { background-color: var(--swatch--sky); }

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - 
CONDITIONAL STYLES BASED ON IF IMAGE OR VIDEO ARE VISIBLE
- - - - - - - - - - - - - - - - - - - - - - - - - - - - */
.hero_tutorial_post_wrap:has(+ .tutorial_post_media_wrap :is(.tutorial_post_image_wrap, .tutorial_post_video_wrap):not(.w-condition-invisible)) {
 border-bottom: none !important;
}

.tutorial_post_media_wrap:has(+ .tutorial_post_wrap:not(.w-condition-invisible)) .u-section-spacer {
 display: none !important;
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - 
TABLE OF CONTENTS
Adding here so classes don't get accidentally cleared
- - - - - - - - - - - - - - - - - - - - - - - - - - - - */
.tutorial_post_toc_list {
 color: var(--_theme---foreground-tertiary); 
 font-size: var(--_typography---font-size--body-3);
}

.tutorial_post_toc_item {
 margin-left: -0.0625rem; 
 padding-top: var(--_spacing---space--0-25rem);
 padding-bottom: var(--_spacing---space--0-25rem); 
 padding-left: var(--_spacing---space--1rem); 
 border-left-style: solid; 
 border-left-width: var(--border-width--main); 
 border-left-color: var(--_theme---border-secondary);
}

.tutorial_post_toc_item.active {
 border-left-color: var(--_theme---heroes-accent);
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - 
ANCHOR LINK
- - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/* offset for <span class="anchor"> that takes fixed header height into account */
.anchor { 
 position: relative;
 top: calc(-1 * var(--_spacing---space--4rem) - 120px); 
}
/* Copy anchor link to clipboard button */
.anchor-link-box {
 /* quick btn reset */
 background: none;
 border: none;
 padding: 0;
 cursor: pointer;
 /* other styles */
 position: absolute !important;
 left: -3rem;
 top: 50%;
 transform: translateY(-50%);
 opacity: 0;
 transition: opacity 0.2s ease;
 width: 2.5rem;
 height: 2.5rem;
 background: var(--_theme---background-tertiary);
 border: var(--border-width--main) solid var(--_theme---border-tertiary);
 border-radius: var(--radius--main);
 display: flex;
 align-items: center;
 justify-content: center;
 padding: var(--_spacing---space--0-5rem);
}

.anchor-link-box:hover {
 opacity: 1;
}

.tooltip {
 opacity: 0;
 transition: opacity 0.2s ease;
 position: absolute;
 left: 50%;
 bottom: calc(100% + 0.5rem);
 transform: translateX(-50%);
 background: var(--_theme---button-primary--background);
 color: var(--_theme---button-primary--text);
 white-space: nowrap;
 padding: 0.125rem 0.5rem;
 border-radius: var(--radius--x-small);
 font-family: var(--_typography---font--primary-family);
 font-size: var(--_typography---font-size--caption);
 line-height: var(--_typography---line-height--1-6);
}

.tooltip.active {
 opacity: 1;
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - 
HIDE EMPTY <p> TAGS
- - - - - - - - - - - - - - - - - - - - - - - - - - - - */
p:empty,
p:has(> br:only-child) {
 display: none;
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - 
BORDER RADIUS ON RICH TEXT VIDEOS
- - - - - - - - - - - - - - - - - - - - - - - - - - - - */
.w-richtext-figure-type-video {
 border-radius: var(--radius--main);
 overflow: hidden;
}
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - 
FIX GRID SPACING IF TUTORIAL HAS NO VIDEO
- - - - - - - - - - - - - - - - - - - - - - - - - - - - */
.tutorial_post_video_layout:has(.w-dyn-bind-empty) {
 display: none;
}

document.addEventListener('DOMContentLoaded', function() {
 // Helper function to convert text to slug
 function textToSlug(text) {
 return text
 .toLowerCase()
 .trim()
 .replace(/[''"&]/g, '')
 .replace(/"([^"]+)"/, '$1')
 .replace(/\s*[:.,?—–\\/-]\s*/g, '-')
 .replace(/\s+/g, '-')
 .replace(/-+/g, '-')
 .replace(/^-+|-+$/g, '');
 }
 
 // Track used slugs to prevent duplicate IDs
 const usedSlugs = new Set();
 
 function getUniqueSlug(baseSlug) {
 let slug = baseSlug;
 let counter = 1;
 while (usedSlugs.has(slug)) {
 slug = `${baseSlug}-${counter}`;
 counter++;
 }
 usedSlugs.add(slug);
 return slug;
 }
 
 // Add/Remove class helper functions
 const addClass = (element, className) => {
 if (element && className) {
 element.classList.add(className);
 }
 };
 
 const removeClass = (element, className) => {
 if (element && className) {
 element.classList.remove(className);
 }
 };
 
 // Debounce helper for resize events
 function debounce(func, wait) {
 let timeout;
 return function executedFunction(...args) {
 const later = () => {
 clearTimeout(timeout);
 func(...args);
 };
 clearTimeout(timeout);
 timeout = setTimeout(later, wait);
 };
 }
 
 // Get elements
 const tutorialContent = document.getElementById('tutorial_content');
 const tocContainer = document.getElementById('tutorial_toc');
 
 if (!tutorialContent || !tocContainer) {
 return;
 }
 
 const h2Elements = tutorialContent.querySelectorAll('h2');
 
 if (h2Elements.length === 0) {
 tocContainer.style.display = 'none';
 return;
 }
 
 // Create ToC list
 const tocList = document.createElement('ul');
 addClass(tocList, 'tutorial_post_toc_list');
 
 const tocItems = [];
 
 // Copy anchor link to clipboard with tooltip
 const copyAnchorToClipboard = (element, spanElement, mouseEnterTime = 750) => {
 let hoverTimeout;
 let tooltip;
 
 element.addEventListener("mouseenter", function () {
 clearTimeout(hoverTimeout);
 tooltip = document.createElement("span");
 addClass(tooltip, 'tooltip');
 tooltip.innerText = "Copy anchor link";
 this.appendChild(tooltip);
 hoverTimeout = setTimeout(() => {
 addClass(tooltip, "active");
 }, mouseEnterTime);
 });

 element.addEventListener("mouseleave", function () {
 clearTimeout(hoverTimeout);
 if (tooltip) {
 removeClass(tooltip, "active");
 this.removeChild(tooltip);
 tooltip = null;
 }
 });

 element.addEventListener("click", function (event) {
 event.preventDefault();
 clearTimeout(hoverTimeout);

 if (spanElement && spanElement.classList.contains("anchor")) {
 const id = spanElement.id;

 if (tooltip) {
 tooltip.innerText = "Copied!";
 addClass(tooltip, "active");

 const url = new URL(window.location.href);
 url.searchParams.delete("topic");
 const anchorLink = `${url.origin}${url.pathname}#${id}`;

 if (navigator && navigator.clipboard) {
 navigator.clipboard.writeText(anchorLink).catch((err) => {
 console.error("Could not copy text: ", err);
 });
 }
 hoverTimeout = setTimeout(() => {
 removeClass(tooltip, "active");
 }, 1500);
 }
 } else {
 console.error("Couldn't find Span with the ID");
 }
 });
 };
 
 // Anchor link SVG icon
 const anchorLinkSVG = `<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 20 20" fill="none"><path d="M7.59608 7.99088C9.01909 7.43035 10.5884 7.86617 11.5326 8.96256L11.7123 9.19108C11.7695 9.27004 11.8243 9.35165 11.8754 9.4362L12.018 9.69792L12.0531 9.79362C12.1116 10.0184 12.0068 10.2611 11.7904 10.3678C11.5738 10.4744 11.3168 10.4098 11.1742 10.2262L11.1205 10.1403L11.018 9.95377C10.9816 9.8936 10.9434 9.83515 10.9027 9.77897L10.7738 9.61491C10.0992 8.83195 8.97855 8.52172 7.96327 8.92155C6.67866 9.42757 6.04713 10.8791 6.55311 12.1637L7.83631 15.4206C8.34249 16.7049 9.794 17.3357 11.0785 16.8298C12.3629 16.3236 12.9937 14.8721 12.4877 13.5876L12.3969 13.3551C12.2957 13.0983 12.4213 12.808 12.6781 12.7067C12.935 12.6055 13.2253 12.732 13.3265 12.9889L13.4183 13.2214C14.1268 15.0198 13.2432 17.052 11.4447 17.7604C9.64625 18.4688 7.61412 17.5852 6.90565 15.7868L5.62245 12.5299C4.91434 10.7317 5.79792 8.69938 7.59608 7.99088ZM8.55506 2.23991C10.3536 1.53146 12.3857 2.41505 13.0941 4.21354L14.3773 7.4694C15.0857 9.26779 14.202 11.2999 12.4037 12.0085C10.9807 12.569 9.41236 12.1332 8.46815 11.0368L8.28749 10.8092C8.17297 10.6512 8.07027 10.481 7.98182 10.3014C7.86013 10.0539 7.96206 9.75458 8.20936 9.63249C8.4571 9.5105 8.7573 9.61229 8.87928 9.86002C8.9425 9.98839 9.0156 10.1089 9.09706 10.2214L9.22596 10.3844C9.90056 11.1677 11.022 11.4788 12.0375 11.0788C13.3218 10.5727 13.9524 9.12105 13.4467 7.83659L12.1644 4.57975C11.6584 3.29511 10.2059 2.66356 8.92128 3.1696C7.63695 3.67569 7.00633 5.12732 7.5121 6.41178L7.60389 6.64518C7.70479 6.902 7.57845 7.19247 7.32167 7.29362C7.06479 7.39475 6.77446 7.26823 6.67323 7.01139L6.58143 6.77897C5.87303 4.98058 6.75677 2.94846 8.55506 2.23991Z" fill="currentColor"/></svg>`;

 // Process each H2 and build ToC
 h2Elements.forEach((h2) => {
 const headingText = h2.textContent;
 const baseSlug = textToSlug(headingText);
 const slug = getUniqueSlug(baseSlug);
 
 // Add anchor span
 const anchorSpan = document.createElement('span');
 anchorSpan.id = slug;
 addClass(anchorSpan, 'anchor');
 h2.prepend(anchorSpan);
 
 // Add anchor link box
 const anchorLinkBox = document.createElement('button');
 anchorLinkBox.type = 'button';
 addClass(anchorLinkBox, 'anchor-link-box');
 anchorLinkBox.innerHTML = anchorLinkSVG;
 h2.prepend(anchorLinkBox);
 
 // Initialize copy functionality
 copyAnchorToClipboard(anchorLinkBox, anchorSpan);
 
 // Create ToC item
 const listItem = document.createElement('li');
 addClass(listItem, 'tutorial_post_toc_item');
 
 const link = document.createElement('a');
 link.href = `#${slug}`;
 
 const textDiv = document.createElement('div');
 textDiv.textContent = headingText;
 
 link.appendChild(textDiv);
 listItem.appendChild(link);
 tocList.appendChild(listItem);
 
 tocItems.push({
 element: listItem,
 target: h2
 });
 });
 
 tocContainer.appendChild(tocList);
 
 // Configuration
 const headerHeight = 134;
 const activationOffset = 100;
 
 // State
 let currentActive = 0;
 let ranges = [];
 let frameRequested = false;
 
 // Calculate activation ranges using getBoundingClientRect for reliability
 // (offsetTop can be relative to offsetParent, not document)
 function calculateRanges() {
 const scrollY = window.scrollY;
 
 ranges = tocItems.map((item, index) => {
 const rect = item.target.getBoundingClientRect();
 const absoluteTop = rect.top + scrollY;
 const activationPoint = absoluteTop - headerHeight - activationOffset;
 
 const nextAbsoluteTop = index < tocItems.length - 1
 ? tocItems[index + 1].target.getBoundingClientRect().top + scrollY
 : Infinity;
 const nextActivation = nextAbsoluteTop === Infinity 
 ? Infinity 
 : nextAbsoluteTop - headerHeight - activationOffset;
 
 return {
 index: index,
 start: Math.max(0, activationPoint),
 end: nextActivation
 };
 });
 }
 
 // Update active section
 function updateActiveSection() {
 if (ranges.length === 0) return;
 
 const scrollPosition = window.scrollY;
 let newActive = 0;
 
 // Find current range
 if (scrollPosition < ranges[0].start) {
 newActive = 0;
 } else {
 for (let i = 0; i < ranges.length; i++) {
 if (scrollPosition >= ranges[i].start && scrollPosition < ranges[i].end) {
 newActive = i;
 break;
 }
 }
 }
 
 // Special case: if near bottom of page, activate last item
 const scrollBottom = scrollPosition + window.innerHeight;
 const documentHeight = document.documentElement.scrollHeight;
 if (documentHeight - scrollBottom < 100) {
 newActive = tocItems.length - 1;
 }
 
 // Update classes if changed
 if (newActive !== currentActive) {
 tocItems.forEach(item => removeClass(item.element, 'active'));
 currentActive = newActive;
 if (tocItems[currentActive]) {
 addClass(tocItems[currentActive].element, 'active');
 }
 }
 
 frameRequested = false;
 }
 
 // Scroll handler
 function handleScroll() {
 if (!frameRequested) {
 frameRequested = true;
 window.requestAnimationFrame(updateActiveSection);
 }
 }
 
 // Recalculate on resize (debounced)
 const handleResize = debounce(() => {
 calculateRanges();
 updateActiveSection();
 }, 250);
 
 // Smooth scroll behavior for ToC links
 tocItems.forEach(item => {
 item.element.querySelector('a').addEventListener('click', function(e) {
 e.preventDefault();
 const targetId = this.getAttribute('href').substring(1);
 const targetElement = document.getElementById(targetId);
 
 if (targetElement) {
 const scrollTo = targetElement.parentElement.offsetTop - headerHeight - 20;
 window.scrollTo({
 top: scrollTo,
 behavior: 'smooth'
 });
 }
 });
 });
 
 // Initialize
 calculateRanges();
 addClass(tocItems[0].element, 'active');
 
 // Handle hash on initial page load
 if (window.location.hash) {
 const hash = window.location.hash.substring(1);
 const targetIndex = tocItems.findIndex(item => 
 item.target.querySelector('.anchor')?.id === hash
 );
 if (targetIndex !== -1) {
 tocItems.forEach(item => removeClass(item.element, 'active'));
 addClass(tocItems[targetIndex].element, 'active');
 currentActive = targetIndex;
 }
 }
 
 // Re-check after browser might restore scroll position
 requestAnimationFrame(() => {
 requestAnimationFrame(() => {
 calculateRanges();
 updateActiveSection();
 });
 });
 
 // Event listeners
 window.addEventListener('scroll', handleScroll, { passive: true });
 window.addEventListener('resize', handleResize);
 
 // Visual Viewport API for mobile viewport changes (keyboard, browser chrome)
 if (window.visualViewport) {
 window.visualViewport.addEventListener('resize', handleResize);
 window.visualViewport.addEventListener('scroll', handleResize);
 }
 
 // Browser back/forward navigation with hash changes
 window.addEventListener('popstate', () => {
 calculateRanges();
 updateActiveSection();
 });
 
 // Handle dynamic content changes (if Webflow adds/removes content)
 const observer = new MutationObserver(debounce(() => {
 calculateRanges();
 updateActiveSection();
 }, 500));
 
 observer.observe(tutorialContent, {
 childList: true,
 subtree: true,
 attributes: false
 });
 
 // Recalculate after images load (affects layout positions)
 const images = tutorialContent.querySelectorAll('img');
 images.forEach(img => {
 if (!img.complete) {
 img.addEventListener('load', handleResize, { once: true });
 img.addEventListener('error', handleResize, { once: true });
 }
 });
 
 // Recalculate after fonts load
 if (document.fonts && document.fonts.ready) {
 document.fonts.ready.then(handleResize);
 }
});
Getting started with Claude in ExcelClaude understands your entire workbook—from nested formulas to multiple tab dependencies. CategoryProfessionalProductClaude in ExcelReading timeWatch time1min7minShareCopy linkhttps://claude.com/resources/tutorials/getting-started-with-claude-in-excelRelated tutorialsHow to use Claude in Excel for accounting: Revenue model validationHow to use Claude in Excel for accounting: Revenue model validationHow to use Claude in Excel for accounting: Revenue model validationTutorialTutorialTutorialCowork, a research previewCowork, a research previewCowork, a research previewTutorialTutorialTutorialUsing the GitHub integrationUsing the GitHub integrationUsing the GitHub integrationTutorialTutorialTutorialUse artifacts to visualize and create AI apps without ever writing a line of codeUse artifacts to visualize and create AI apps without ever writing a line of codeUse artifacts to visualize and create AI apps without ever writing a line of codeTutorialTutorialTutorial
 @container (width < 52em) {
 .footer_layout {
 display: flex;
 column-gap: var(--_spacing---space--4rem);
 row-gap: var(--_spacing---space--4rem);
 }
 .footer_content_wrap.u-column-custom {
 display: contents;
 }
 }

 .footer_link {
 opacity: 1;
 transition: opacity 0.3s ease;
 }
 .footer_links_list:has(.footer_link:hover) .footer_link:not(:hover) {
 opacity: 0.4;
 }
HomepageHomepageNextNextThank you! Your submission has been received!Oops! Something went wrong while submitting the form.
 (function () {
 const ROOT_SEL = "[data-prompt-scope]";
 const TRIGGER_SEL = "[data-prompt-trigger]";
 const MENU_ATTR = "data-prompt-menu";
 const CLOSE_SEL = "[data-prompt-menu-close]";
 const ACTION_SEL = "a, button, [data-prompt-menu-action]";
 const ITEM_SEL = "[data-prompt-item], li, .menu-item, .w-dyn-item";

 // ---------- Claude helper ----------
 function buildClaudeUrl(text) {
 const url = new URL("https://claude.ai/new");
 url.searchParams.set("q", text || "");
 return url.toString();
 }
 function openClaude(text) {
 const q = (text || "").trim();
 if (!q) return;
 window.open(buildClaudeUrl(q), "_blank", "noopener");
 }

 // ---------- Utilities ----------
 let uid = 0;
 function makeId(prefix = "prompt-menu") {
 uid += 1;
 return `${prefix}-${Date.now().toString(36)}-${uid}`;
 }

 // Limit queries to elements that belong to THIS scope (ignore nested scopes)
 function qsaInScope(root, sel) {
 return Array.from(root.querySelectorAll(sel)).filter(
 (el) => el.closest(ROOT_SEL) === root
 );
 }

 // Lightweight shield to stop click-through during the brief close animation
 function deployClickShield(ms = 300) {
 const sh = document.createElement("div");
 sh.style.cssText =
 "position:fixed;inset:0;z-index:2147483647;pointer-events:auto;background:transparent";
 document.body.appendChild(sh);
 setTimeout(() => {
 sh.remove();
 }, ms);
 }

 // Pairing: find which menu a trigger controls (no manual ids needed)
 function resolveMenuForTrigger(root, trigger) {
 // 1) explicit data-prompt-trigger="x" -> [data-prompt-menu="x"]
 const explicit = trigger.getAttribute("data-prompt-trigger");
 if (explicit) {
 const m = qsaInScope(root, `[${MENU_ATTR}="${explicit}"]`)[0];
 if (m) return m;
 }
 // 2) aria-controls
 const ctrl = trigger.getAttribute("aria-controls");
 if (ctrl) {
 const m = qsaInScope(root, `#${ctrl.replace(/(["'\\])/g, "\\$1")}`)[0];
 if (m) return m;
 }
 // 3) nearest following sibling with [data-prompt-menu]
 let sib = trigger.nextElementSibling;
 while (sib && sib !== root) {
 if (
 sib.hasAttribute &&
 sib.hasAttribute(MENU_ATTR) &&
 sib.closest(ROOT_SEL) === root
 )
 return sib;
 sib = sib.nextElementSibling;
 }
 // 4) first menu in this root
 return qsaInScope(root, `[${MENU_ATTR}]`)[0] || null;
 }

 function ensurePairing(trigger, menu) {
 if (!menu.id) menu.id = makeId();
 trigger.setAttribute("aria-controls", menu.id);
 if (trigger.tagName === "BUTTON" && !trigger.hasAttribute("type"))
 trigger.type = "button";
 }

 // ---------- Animations (GSAP) ----------
 function revealMenu(menu) {
 return new Promise((resolve) => {
 gsap.set(menu, {
 visibility: "visible",
 pointerEvents: "auto",
 willChange: "transform, opacity",
 });
 gsap.killTweensOf(menu);
 gsap.fromTo(
 menu,
 { opacity: 0, scale: 0.96 },
 {
 opacity: 1,
 scale: 1,
 duration: 0.28,
 ease: "power3.out",
 clearProps: "willChange",
 onComplete: resolve,
 }
 );
 });
 }
 function hideMenu(menu) {
 return new Promise((resolve) => {
 gsap.killTweensOf(menu);
 gsap.to(menu, {
 opacity: 0,
 duration: 0.2,
 ease: "power2.out",
 onComplete: () => {
 gsap.set(menu, {
 visibility: "hidden",
 pointerEvents: "none",
 clearProps: "opacity,scale,willChange",
 });
 resolve();
 },
 });
 });
 }

 // ---------- Per-scope controller ----------
 const stateMap = new WeakMap(); // root -> { openMenuEl, openTrigger, isAnimating }

 function getState(root) {
 let s = stateMap.get(root);
 if (!s) {
 s = { openMenuEl: null, openTrigger: null, isAnimating: false };
 stateMap.set(root, s);
 }
 return s;
 }

 function setTriggersInteractive(root, enabled) {
 qsaInScope(root, TRIGGER_SEL).forEach((el) => {
 el.style.pointerEvents = enabled ? "auto" : "none";
 });
 }

 // ---------- Button fade animations ----------
 function fadeOutButtons(root) {
 return new Promise((resolve) => {
 const buttons = qsaInScope(root, TRIGGER_SEL);
 if (buttons.length === 0) {
 resolve();
 return;
 }

 gsap.killTweensOf(buttons);
 gsap.to(buttons, {
 autoAlpha: 0,
 duration: 0.2,
 ease: "power2.out",
 onComplete: resolve,
 });
 });
 }

 function fadeInButtons(root) {
 return new Promise((resolve) => {
 const buttons = qsaInScope(root, TRIGGER_SEL);
 if (buttons.length === 0) {
 resolve();
 return;
 }

 gsap.killTweensOf(buttons);
 gsap.to(buttons, {
 autoAlpha: 1,
 duration: 0.2,
 ease: "power2.out",
 onComplete: resolve,
 });
 });
 }

 async function openMenuIn(root, menu, trigger) {
 const s = getState(root);
 if (s.isAnimating || s.openMenuEl === menu) return;
 s.isAnimating = true;

 // close any currently open in THIS scope only
 if (s.openMenuEl && s.openMenuEl !== menu) {
 await hideMenu(s.openMenuEl);
 if (s.openTrigger) s.openTrigger.setAttribute("aria-expanded", "false");
 }

 // Fade out buttons when opening menu
 await fadeOutButtons(root);

 await revealMenu(menu);
 s.openMenuEl = menu;
 s.openTrigger = trigger || null;
 if (s.openTrigger) s.openTrigger.setAttribute("aria-expanded", "true");

 // Disable only this scope's triggers while open
 setTriggersInteractive(root, false);

 s.isAnimating = false;
 }

 async function closeMenuIn(root) {
 const s = getState(root);
 if (!s.openMenuEl || s.isAnimating) return;
 s.isAnimating = true;

 deployClickShield(280); // prevent click-through during closing
 await hideMenu(s.openMenuEl);

 if (s.openTrigger) s.openTrigger.setAttribute("aria-expanded", "false");
 s.openMenuEl = null;
 s.openTrigger = null;

 // Re-enable only this scope's triggers
 setTriggersInteractive(root, true);

 // Fade in buttons when closing menu
 await fadeInButtons(root);

 s.isAnimating = false;
 }

 // ---------- Initializer ----------
 const initedRoots = new WeakSet();

 function initScope(root) {
 if (!root || initedRoots.has(root)) return;
 initedRoots.add(root);

 if (!window.gsap) {
 console.warn("GSAP is required for prompt menus.");
 return;
 }

 // Normalize ALL menus in this scope to hidden on init (prevents “open on load” bugs)
 qsaInScope(root, `[${MENU_ATTR}]`).forEach((menu) => {
 if (menu.dataset.pmMenuInit) return;
 menu.dataset.pmMenuInit = "true";
 gsap.set(menu, {
 visibility: "hidden",
 opacity: 0,
 scale: 1,
 pointerEvents: "none",
 });

 // Optional close button
 const closer = menu.querySelector(CLOSE_SEL);
 if (closer) {
 if (closer.tagName === "BUTTON" && !closer.hasAttribute("type"))
 closer.type = "button";
 closer.addEventListener("click", (e) => {
 e.preventDefault();
 e.stopPropagation();
 closeMenuIn(root);
 });
 }

 // Menu item -> Claude
 menu.addEventListener("click", (e) => {
 const target = e.target.closest(ACTION_SEL);
 if (!target || !menu.contains(target)) return;

 const container = target.closest(ITEM_SEL) || target;
 const hiddenP = container.querySelector("[data-prompt-menu-text]");
 if (!hiddenP) return;

 e.preventDefault();
 e.stopPropagation();

 const text = hiddenP.textContent || hiddenP.innerText || "";
 openClaude(text);

 // close after action
 closeMenuIn(root);
 });
 });

 // Bind triggers (auto-wire)
 qsaInScope(root, TRIGGER_SEL).forEach((trigger) => {
 if (trigger.dataset.pmTrigInit) return;
 trigger.dataset.pmTrigInit = "true";

 const menu = resolveMenuForTrigger(root, trigger);
 if (menu) ensurePairing(trigger, menu);

 trigger.setAttribute("aria-expanded", "false");

 trigger.addEventListener("click", async (e) => {
 e.preventDefault();

 const targetMenu = resolveMenuForTrigger(root, trigger);
 if (!targetMenu) return;

 const s = getState(root);
 if (s.openMenuEl === targetMenu) {
 await closeMenuIn(root); // toggle close
 return;
 }
 await openMenuIn(root, targetMenu, trigger);
 });
 });

 // Outside click (this scope only)
 document.addEventListener("click", (e) => {
 const s = getState(root);
 if (!s.openMenuEl) return;
 const insideMenu = s.openMenuEl.contains(e.target);
 const onTrigger =
 !!e.target.closest(TRIGGER_SEL) && root.contains(e.target);
 if (!insideMenu && !onTrigger) closeMenuIn(root);
 });

 // ESC (this scope only)
 document.addEventListener("keydown", (e) => {
 if (e.key === "Escape") closeMenuIn(root);
 });
 }

 // ---------- Boot + observe ----------
 function boot(container = document) {
 const roots = container.querySelectorAll
 ? container.querySelectorAll(ROOT_SEL)
 : [];
 roots.forEach(initScope);
 }

 if (document.readyState === "loading") {
 document.addEventListener("DOMContentLoaded", () => boot(), {
 once: true,
 });
 } else {
 boot();
 }

 const mo = new MutationObserver((muts) => {
 for (const m of muts) {
 for (const node of m.addedNodes || []) {
 if (node.nodeType !== 1) continue;
 if (node.matches && node.matches(ROOT_SEL)) initScope(node);
 if (node.querySelectorAll) {
 node.querySelectorAll(ROOT_SEL).forEach(initScope);
 }
 }
 }
 });
 mo.observe(document.documentElement, { childList: true, subtree: true });
 })();

(function () {
 // ---------- Claude helper ----------
 function buildClaudeUrl(text) {
 const url = new URL('https://claude.ai/new');
 url.searchParams.set('q', text || '');
 return url.toString();
 }

 // ---------- Auto-grow helpers ----------
 function sizeTextarea(el) {
 // Ensure UA defaults don't force a starting height
 el.setAttribute('rows', el.getAttribute('data-min-rows') || '1');
 el.style.minHeight = '0px';
 el.style.height = 'auto'; // allow shrink
 el.style.height = el.scrollHeight + 'px'; // fit content
 }

 function initAutogrow(root = document) {
 root.querySelectorAll('textarea[data-autogrow]').forEach((el) => {
 if (el.dataset.autogrowInit) return;
 el.dataset.autogrowInit = 'true';

 // Respect your existing pattern for default text
 const preset = el.getAttribute('data-default-text');
 if (preset != null && !el.value) el.value = preset;

 // Initial sizing
 sizeTextarea(el);

 // Resize as you type
 el.addEventListener('input', () => sizeTextarea(el));

 // In case fonts/styles load late and change line-height
 window.addEventListener('load', () => sizeTextarea(el), { once: true });
 });
 }

 // ---------- Claude form initializer ----------
 function initClaudeForms(root = document) {
 root.querySelectorAll('form[data-claude-form]').forEach((form) => {
 if (form.dataset.claudeInit) return;
 form.dataset.claudeInit = 'true';

 const textarea = form.querySelector('[data-claude-textarea], textarea');
 const trigger = form.querySelector('[data-claude-button], button[type="button"], a[data-claude-button]');

 if (!textarea || !trigger) {
 console.warn('Claude form: missing textarea or trigger in', form);
 return;
 }

 // If the trigger is a <button> but has no type, force "button" so it won't submit
 if (trigger.tagName === 'BUTTON' && !trigger.hasAttribute('type')) {
 trigger.type = 'button';
 }

 // Keep <a> from navigating away while still opening Claude
 if (trigger.tagName === 'A') {
 trigger.addEventListener('click', (e) => e.preventDefault());
 }

 // Optional: support data-default-text on the textarea
 const preset = textarea.getAttribute('data-default-text');
 if (preset != null && !textarea.value) textarea.value = preset;

 // Click opens Claude; submission is optional
 trigger.addEventListener('click', () => {
 const text = (textarea.value || '').trim();
 if (!text) {
 textarea.focus();
 return;
 }

 window.open(buildClaudeUrl(text), '_blank', 'noopener');

 const mode = form.getAttribute('data-claude-mode') || 'intercept';
 if (mode === 'also') {
 // Submit after opening Claude
 form.submit();
 }
 // intercept mode: do nothing (no submit)
 });

 // (Optional) Keep an <a data-claude-button> href in sync for right-click/open-in-new-tab UX
 if (trigger.tagName === 'A') {
 const syncHref = () => trigger.setAttribute('href', buildClaudeUrl((textarea.value || '').trim()));
 syncHref();
 textarea.addEventListener('input', syncHref);
 textarea.addEventListener('change', syncHref);
 }
 });
 }

 // ---------- Boot ----------
 function initAll(root = document) {
 initAutogrow(root);
 initClaudeForms(root);
 }

 if (document.readyState === 'loading') {
 document.addEventListener('DOMContentLoaded', () => initAll(), { once: true });
 } else {
 initAll();
 }

 // Re-init if content is injected later (Webflow CMS / IX / tabs)
 const mo = new MutationObserver((muts) => {
 for (const m of muts) {
 for (const node of m.addedNodes || []) {
 if (node.nodeType === 1) initAll(node);
 }
 }
 });
 mo.observe(document.documentElement, { childList: true, subtree: true });
})();

 .prompt_menu_item {
 transition: border-color 0.2s ease, color 0.2s ease;
 }
 .prompt_menu_item_base, .prompt_menu_item_icon {
 transition: opacity 0.2s ease;
 }
 .prompt_menu_list .prompt_menu_item:first-child {
 border-color: transparent;
 }
 .prompt_menu_item:hover {
 border-color: transparent;
 color: var(--_theme---foreground-primary);
 }
 .prompt_menu_item:hover .prompt_menu_item_base {
 opacity: 1;
 }
 .prompt_menu_item:hover .prompt_menu_item_icon {
 opacity: 1;
 }
 .prompt_menu_item:hover + .prompt_menu_item {
 border-top-color: transparent;
 }

 .button_prompt_icon {
 transition: color 0.3s ease;
 }
 .button_prompt_wrap:hover .button_prompt_icon {
 color: var(--_button-style---icon-hover); 
 }
 .button_prompt_wrap:focus-within .button_prompt_icon {
 color: var(--_button-style---text-hover) !important;
 }
 .button_prompt_wrap:focus-within {
 color: var(--_button-style---text-hover) !important;
 }

WriteButton TextButton TextLearnButton TextButton TextCodeButton TextButton TextWriteHelp me develop a unique voice for an audienceHi Claude! Could you help me develop a unique voice for an audience? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational. Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!Improve my writing styleHi Claude! Could you improve my writing style? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational. Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!Brainstorm creative ideasHi Claude! Could you brainstorm creative ideas? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational. Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!LearnExplain a complex topic simplyHi Claude! Could you explain a complex topic simply? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational. Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!Help me make sense of these ideasHi Claude! Could you help me make sense of these ideas? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational. Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!Prepare for an exam or interviewHi Claude! Could you prepare for an exam or interview? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational. Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!CodeExplain a programming conceptHi Claude! Could you explain a programming concept? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational. Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!Look over my code and give me tipsHi Claude! Could you look over my code and give me tips? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational. Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!Vibe code with meHi Claude! Could you vibe code with me? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to— like Google Drive, web search, etc.—if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational. Please execute the task as soon as you can—an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!MoreWrite case studiesThis is another testWrite grant proposalsHi Claude! Could you write grant proposals? If you need more information from me, ask me 1-2 key questions right away. If you think I should upload any documents that would help you do a better job, let me know. You can use the tools you have access to — like Google Drive, web search, etc. — if they’ll help you better accomplish this task. Do not use analysis tool. Please keep your responses friendly, brief and conversational. Please execute the task as soon as you can - an artifact would be great if it makes sense. If using an artifact, consider what kind of artifact (interactive, visual, checklist, etc.) might be most helpful for this specific task. Thanks for your help!Write video scriptsthis is a testAnthropicAnthropic© 2026 Anthropic PBCProductsClaudeClaudeClaudeClaude CodeClaude CodeClaude CodeCoworkCoworkCoworkMax planMax planMax planTeam planTeam planTeam planEnterprise planEnterprise planEnterprise planDownload appDownload appDownload appPricingPricingPricingLog inLog inLog inFeaturesClaude in ChromeClaude in ChromeClaude in ChromeClaude in SlackClaude in SlackClaude in SlackClaude in ExcelClaude in ExcelClaude in ExcelSkillsSkillsSkillsModelsOpusOpusOpusSonnetSonnetSonnetHaikuHaikuHaikuSolutionsAI agentsAI agentsAI agentsCode modernizationCode modernizationCode modernizationCodingCodingCodingCustomer supportCustomer supportCustomer supportEducationEducationEducationFinancial servicesFinancial servicesFinancial servicesGovernmentGovernmentGovernmentHealthcareHealthcareHealthcareLife sciencesLife sciencesLife sciencesNonprofitsNonprofitsNonprofitsClaude Developer PlatformOverviewOverviewOverviewDeveloper docsDeveloper docsDeveloper docsPricingPricingPricingRegional ComplianceRegional ComplianceRegional ComplianceAmazon BedrockAmazon BedrockAmazon BedrockGoogle Cloud’s Vertex AIGoogle Cloud’s Vertex AIGoogle Cloud’s Vertex AIConsole loginConsole loginConsole loginLearnBlogBlogBlogClaude partner networkClaude partner networkClaude partner networkCoursesCoursesCoursesConnectorsConnectorsConnectorsCustomer storiesCustomer storiesCustomer storiesEngineering at AnthropicEngineering at AnthropicEngineering at AnthropicEventsEventsEventsPluginsPluginsPluginsPowered by ClaudePowered by ClaudePowered by ClaudeService partnersService partnersService partnersStartups programStartups programStartups programTutorialsTutorialsTutorialsUse casesUse casesUse casesCompanyAnthropicAnthropicAnthropicCareersCareersCareersEconomic FuturesEconomic FuturesEconomic FuturesResearchResearchResearchNewsNewsNewsResponsible Scaling PolicyResponsible Scaling PolicyResponsible Scaling PolicySecurity and complianceSecurity and complianceSecurity and complianceTransparencyTransparencyTransparencyHelp and securityAvailabilityAvailabilityAvailabilityStatusStatusStatusSupport centerSupport centerSupport centerTerms and policiesPrivacy choices
 /* Dialog styling */
 dialog#consent-container {
 margin: 0;
 padding: 8px;
 opacity: 0;
 transform: translateY(16px);
 transition: opacity 0.3s ease-out, transform 0.3s ease-out;
 }

 dialog#consent-container.show {
 opacity: 1;
 transform: translateY(0);
 }

 dialog#consent-container::backdrop {
 background: transparent;
 }

 dialog button span {
 display: inline !important;
 }

 /* Toggle switch styling */
 .toggle_switch {
 position: relative;
 display: inline-block;
 width: 36px;
 height: 24px;
 }

 .toggle_switch input {
 opacity: 0;
 width: 0;
 height: 0;
 }

 .toggle_slider {
 position: absolute;
 cursor: pointer;
 top: 0;
 left: 0;
 right: 0;
 bottom: 0;
 background-color: #87867f;
 transition: .4s;
 border-radius: 24px;
 }

 .toggle_slider:before {
 position: absolute;
 content: "";
 height: 18px;
 width: 18px;
 left: 3px;
 bottom: 3px;
 background-color: white;
 transition: .4s;
 border-radius: 50%;
 }

 input:checked + .toggle_slider {
 background-color: #d97757;
 }

 input:checked + .toggle_slider:before {
 transform: translateX(12px);
 }

 input:disabled + .toggle_slider {
 cursor: not-allowed;
 opacity: 0.5;
 }

 @media only screen and (max-width: 501px) {
 dialog#consent-container {
 left: 8px !important;
 bottom: 8px !important;
 right: 8px !important;
 }
 #consent-banner {
 padding: 24px 16px 16px !important;
 }
 #simple-options {
 grid-template-columns: repeat(3, 1fr) !important;
 grid-template-rows: auto auto !important;
 }
 #customize-btn {
 grid-column: span 1 !important;
 }
 dialog button span {
 display: none !important;
 }

 
 Cookie settings
 
 We use cookies to deliver and improve our services, analyze site usage, and if you agree, to customize or personalize your experience and market our services to you. You can read our Cookie Policy here.
 

 Customize cookie settings
 
 
 Reject all cookies
 
 
 Accept all cookies
 
 
 Necessary
 Enables security and basic functionality.
 
 
 Required
 
 
 Analytics
 Enables tracking of site performance.
 
 
 Off
 
 
 Marketing
 Enables ads personalization and tracking.
 
 
 Off
 
 
 Save preferences
 
 
Privacy policyPrivacy policyPrivacy policyResponsible disclosure policyResponsible disclosure policyResponsible disclosure policyTerms of service: CommercialTerms of service: CommercialTerms of service: CommercialTerms of service: ConsumerTerms of service: ConsumerTerms of service: ConsumerUsage policyUsage policyUsage policyx.comx.comLinkedInLinkedInYouTubeYouTubeInstagramInstagramEnglish (US)

 function initDynamicCurrentYear() { 
 const currentYear = new Date().getFullYear();
 const currentYearElements = document.querySelectorAll('[data-current-year]');
 currentYearElements.forEach(currentYearElement => {
 currentYearElement.textContent = currentYear;
 });
 }

 // Initialize Dynamic Current Year
 document.addEventListener('DOMContentLoaded', () => {
 initDynamicCurrentYear();
 });
gsap.registerPlugin(ScrollTrigger,SplitText,TextPlugin,Flip,Draggable,InertiaPlugin);

 document.addEventListener('DOMContentLoaded', function() {
 const contentElement = document.querySelector('[data-readtime="content"]');
 const minutesElement = document.querySelector('[data-readtime="minutes"]');

 if (!contentElement || !minutesElement) return;

 const text = contentElement.innerText || contentElement.textContent;
 const wordCount = text.trim().split(/\s+/).length;
 const wordsPerMinute = 250;
 const minutes = Math.round(wordCount / wordsPerMinute);

 minutesElement.textContent = minutes || 1; // minimum 1 minute
 });
 
 // Hide all empty paragraph tags from the main content RTF
 document.querySelectorAll('#tutorial_content p').forEach(p => {
 if (p.textContent.trim() === '' || /^[\u200B-\u200D\uFEFF]+$/.test(p.textContent)) {
 p.remove();
 }
 });

 
 ×


---
## setup.md

> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Set up Claude Code

> Install, authenticate, and start using Claude Code on your development machine.

## System requirements

* **Operating Systems**: macOS 13.0+, Ubuntu 20.04+/Debian 10+, or Windows 10 1809+ / Windows Server 2019+ (with WSL 1, WSL 2, or Git for Windows)
* **Hardware**: 4 GB+ RAM
* **Network**: Internet connection required (see [network configuration](/en/network-config#network-access-requirements))
* **Shell**: Works best in Bash or Zsh
* **Location**: [Anthropic supported countries](https://www.anthropic.com/supported-countries)

### Additional dependencies

* **ripgrep**: Usually included with Claude Code. If search fails, see [search troubleshooting](/en/troubleshooting#search-and-discovery-issues).
* **[Node.js 18+](https://nodejs.org/en/download)**: Only required for [deprecated npm installation](#npm-installation-deprecated)

## Installation

To install Claude Code, use one of the following methods:

<Tabs>
  <Tab title="Native Install (Recommended)">
    **macOS, Linux, WSL:**

    ```bash  theme={null}
    curl -fsSL https://claude.ai/install.sh | bash
    ```

    **Windows PowerShell:**

    ```powershell  theme={null}
    irm https://claude.ai/install.ps1 | iex
    ```

    **Windows CMD:**

    ```batch  theme={null}
    curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd
    ```

    <Info>
      Native installations automatically update in the background to keep you on the latest version.
    </Info>
  </Tab>

  <Tab title="Homebrew">
    ```sh  theme={null}
    brew install --cask claude-code
    ```

    <Info>
      Homebrew installations do not auto-update. Run `brew upgrade claude-code` periodically to get the latest features and security fixes.
    </Info>
  </Tab>

  <Tab title="WinGet">
    ```powershell  theme={null}
    winget install Anthropic.ClaudeCode
    ```

    <Info>
      WinGet installations do not auto-update. Run `winget upgrade Anthropic.ClaudeCode` periodically to get the latest features and security fixes.
    </Info>
  </Tab>
</Tabs>

After the installation process completes, navigate to your project and start Claude Code:

```bash  theme={null}
cd your-awesome-project
claude
```

If you encounter any issues during installation, consult the [troubleshooting guide](../21-Account-Support/troubleshooting-claude-code-docs-3f3657ed0f.md).

<Tip>
  Run `claude doctor` after installation to check your installation type and version.
</Tip>

<Note>
  **Alpine Linux and other musl/uClibc-based distributions**: The native installer requires `libgcc`, `libstdc++`, and `ripgrep`. For Alpine: `apk add libgcc libstdc++ ripgrep`. Set `USE_BUILTIN_RIPGREP=0`.
</Note>

### Authentication

#### For individuals

1. **Claude Pro or Max plan** (recommended): Subscribe to Claude's [Pro or Max plan](https://claude.ai/pricing) for a unified subscription that includes both Claude Code and Claude on the web. Manage your account in one place and log in with your Claude.ai account.
2. **Claude Console**: Connect through the [Claude Console](https://console.anthropic.com) and complete the OAuth process. Requires active billing in the Anthropic Console. A "Claude Code" workspace is automatically created for usage tracking and cost management. You can't create API keys for the Claude Code workspace; it's dedicated exclusively for Claude Code usage.

#### For teams and organizations

1. **Claude for Teams or Enterprise** (recommended): Subscribe to [Claude for Teams](https://claude.com/pricing#team-&-enterprise) or [Claude for Enterprise](https://anthropic.com/contact-sales) for centralized billing, team management, and access to both Claude Code and Claude on the web. Team members log in with their Claude.ai accounts.
2. **Claude Console with team billing**: Set up a shared [Claude Console](https://console.anthropic.com) organization with team billing. Invite team members and assign roles for usage tracking.
3. **Cloud providers**: Configure Claude Code to use [Amazon Bedrock, Google Vertex AI, or Microsoft Foundry](../02-Claude-Code-CLI/enterprise-deployment-overview-claude-code-docs-6eae0ecba2.md) for deployments with your existing cloud infrastructure.

### Install a specific version

The native installer accepts either a specific version number or a release channel (`latest` or `stable`). The channel you choose at install time becomes your default for auto-updates. See [Configure release channel](#configure-release-channel) for more information.

To install the latest version (default):

<Tabs>
  <Tab title="macOS, Linux, WSL">
    ```bash  theme={null}
    curl -fsSL https://claude.ai/install.sh | bash
    ```
  </Tab>

  <Tab title="Windows PowerShell">
    ```powershell  theme={null}
    irm https://claude.ai/install.ps1 | iex
    ```
  </Tab>

  <Tab title="Windows CMD">
    ```batch  theme={null}
    curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd
    ```
  </Tab>
</Tabs>

To install the stable version:

<Tabs>
  <Tab title="macOS, Linux, WSL">
    ```bash  theme={null}
    curl -fsSL https://claude.ai/install.sh | bash -s stable
    ```
  </Tab>

  <Tab title="Windows PowerShell">
    ```powershell  theme={null}
    & ([scriptblock]::Create((irm https://claude.ai/install.ps1))) stable
    ```
  </Tab>

  <Tab title="Windows CMD">
    ```batch  theme={null}
    curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd stable && del install.cmd
    ```
  </Tab>
</Tabs>

To install a specific version number:

<Tabs>
  <Tab title="macOS, Linux, WSL">
    ```bash  theme={null}
    curl -fsSL https://claude.ai/install.sh | bash -s 1.0.58
    ```
  </Tab>

  <Tab title="Windows PowerShell">
    ```powershell  theme={null}
    & ([scriptblock]::Create((irm https://claude.ai/install.ps1))) 1.0.58
    ```
  </Tab>

  <Tab title="Windows CMD">
    ```batch  theme={null}
    curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd 1.0.58 && del install.cmd
    ```
  </Tab>
</Tabs>

### Binary integrity and code signing

* SHA256 checksums for all platforms are published in the release manifests, currently located at `https://storage.googleapis.com/claude-code-dist-86c565f3-f756-42ad-8dfa-d59b1c096819/claude-code-releases/{VERSION}/manifest.json` (example: replace `{VERSION}` with `2.0.30`)
* Signed binaries are distributed for the following platforms:
  * macOS: Signed by "Anthropic PBC" and notarized by Apple
  * Windows: Signed by "Anthropic, PBC"

## NPM installation (deprecated)

NPM installation is deprecated. Use the [native installation](#installation) method when possible. To migrate an existing npm installation to native, run `claude install`.

**Global npm installation**

```sh  theme={null}
npm install -g @anthropic-ai/claude-code
```

<Warning>
  Do NOT use `sudo npm install -g` as this can lead to permission issues and security risks.
  If you encounter permission errors, see [troubleshooting permission errors](/en/troubleshooting#command-not-found-claude-or-permission-errors) for recommended solutions.
</Warning>

## Windows setup

**Option 1: Claude Code within WSL**

* Both WSL 1 and WSL 2 are supported
* WSL 2 supports [sandboxing](../22-Safety-Policy/sandboxing-claude-code-docs-5f97cd27c4.md) for enhanced security. WSL 1 does not support sandboxing.

**Option 2: Claude Code on native Windows with Git Bash**

* Requires [Git for Windows](https://git-scm.com/downloads/win)
* For portable Git installations, specify the path to your `bash.exe`:
  ```powershell  theme={null}
  $env:CLAUDE_CODE_GIT_BASH_PATH="C:\Program Files\Git\bin\bash.exe"
  ```

## Update Claude Code

### Auto updates

Claude Code automatically keeps itself up to date to ensure you have the latest features and security fixes.

* **Update checks**: Performed on startup and periodically while running
* **Update process**: Downloads and installs automatically in the background
* **Notifications**: You'll see a notification when updates are installed
* **Applying updates**: Updates take effect the next time you start Claude Code

<Note>
  Homebrew and WinGet installations do not auto-update. Use `brew upgrade claude-code` or `winget upgrade Anthropic.ClaudeCode` to update manually.

  **Known issue:** Claude Code may notify you of updates before the new version is available in these package managers. If an upgrade fails, wait and try again later.
</Note>

### Configure release channel

Configure which release channel Claude Code follows for both auto-updates and `claude update` with the `autoUpdatesChannel` setting:

* `"latest"` (default): Receive new features as soon as they're released
* `"stable"`: Use a version that is typically about one week old, skipping releases with major regressions

Configure this via `/config` → **Auto-update channel**, or add it to your [settings.json file](../02-Claude-Code-CLI/claude-code-settings-claude-code-docs-d4420b4b52.md):

```json  theme={null}
{
  "autoUpdatesChannel": "stable"
}
```

For enterprise deployments, you can enforce a consistent release channel across your organization using [managed settings](/en/iam#managed-settings).

### Disable auto-updates

Set the `DISABLE_AUTOUPDATER` environment variable in your shell or [settings.json file](../02-Claude-Code-CLI/claude-code-settings-claude-code-docs-d4420b4b52.md):

```bash  theme={null}
export DISABLE_AUTOUPDATER=1
```

### Update manually

```bash  theme={null}
claude update
```

## Uninstall Claude Code

If you need to uninstall Claude Code, follow the instructions for your installation method.

### Native installation

Remove the Claude Code binary and version files:

**macOS, Linux, WSL:**

```bash  theme={null}
rm -f ~/.local/bin/claude
rm -rf ~/.local/share/claude
```

**Windows PowerShell:**

```powershell  theme={null}
Remove-Item -Path "$env:USERPROFILE\.local\bin\claude.exe" -Force
Remove-Item -Path "$env:USERPROFILE\.local\share\claude" -Recurse -Force
```

**Windows CMD:**

```batch  theme={null}
del "%USERPROFILE%\.local\bin\claude.exe"
rmdir /s /q "%USERPROFILE%\.local\share\claude"
```

### Homebrew installation

```bash  theme={null}
brew uninstall --cask claude-code
```

### WinGet installation

```powershell  theme={null}
winget uninstall Anthropic.ClaudeCode
```

### NPM installation

```bash  theme={null}
npm uninstall -g @anthropic-ai/claude-code
```

### Clean up configuration files (optional)

<Warning>
  Removing configuration files will delete all your settings, allowed tools, MCP server configurations, and session history.
</Warning>

To remove Claude Code settings and cached data:

**macOS, Linux, WSL:**

```bash  theme={null}
# Remove user settings and state
rm -rf ~/.claude
rm ~/.claude.json

# Remove project-specific settings (run from your project directory)
rm -rf .claude
rm -f .mcp.json
```

**Windows PowerShell:**

```powershell  theme={null}
# Remove user settings and state
Remove-Item -Path "$env:USERPROFILE\.claude" -Recurse -Force
Remove-Item -Path "$env:USERPROFILE\.claude.json" -Force

# Remove project-specific settings (run from your project directory)
Remove-Item -Path ".claude" -Recurse -Force
Remove-Item -Path ".mcp.json" -Force
```

**Windows CMD:**

```batch  theme={null}
REM Remove user settings and state
rmdir /s /q "%USERPROFILE%\.claude"
del "%USERPROFILE%\.claude.json"

REM Remove project-specific settings (run from your project directory)
rmdir /s /q ".claude"
del ".mcp.json"
```


---
## third-party-integrations.md

> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Enterprise deployment overview

> Learn how Claude Code can integrate with various third-party services and infrastructure to meet enterprise deployment requirements.

Organizations can deploy Claude Code through Anthropic directly or through a cloud provider. This page helps you choose the right configuration.

## Compare deployment options

For most organizations, Claude for Teams or Claude for Enterprise provides the best experience. Team members get access to both Claude Code and Claude on the web with a single subscription, centralized billing, and no infrastructure setup required.

**Claude for Teams** is self-service and includes collaboration features, admin tools, and billing management. Best for smaller teams that need to get started quickly.

**Claude for Enterprise** adds SSO and domain capture, role-based permissions, compliance API access, and managed policy settings for deploying organization-wide Claude Code configurations. Best for larger organizations with security and compliance requirements.

Learn more about [Team plans](../17-Billing-Plans/what-is-the-team-plan.md) and [Enterprise plans](../17-Billing-Plans/what-is-the-enterprise-plan.md).

If your organization has specific infrastructure requirements, compare the options below:

<table>
  <thead>
    <tr>
      <th>Feature</th>
      <th>Claude for Teams/Enterprise</th>
      <th>Anthropic Console</th>
      <th>Amazon Bedrock</th>
      <th>Google Vertex AI</th>
      <th>Microsoft Foundry</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td>Best for</td>
      <td>Most organizations (recommended)</td>
      <td>Individual developers</td>
      <td>AWS-native deployments</td>
      <td>GCP-native deployments</td>
      <td>Azure-native deployments</td>
    </tr>

    <tr>
      <td>Billing</td>
      <td><strong>Teams:</strong> \$150/seat (Premium) with PAYG available<br /><strong>Enterprise:</strong> <a href="https://claude.com/contact-sales">Contact Sales</a></td>
      <td>PAYG</td>
      <td>PAYG through AWS</td>
      <td>PAYG through GCP</td>
      <td>PAYG through Azure</td>
    </tr>

    <tr>
      <td>Regions</td>
      <td>Supported [countries](https://www.anthropic.com/supported-countries)</td>
      <td>Supported [countries](https://www.anthropic.com/supported-countries)</td>
      <td>Multiple AWS [regions](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html)</td>
      <td>Multiple GCP [regions](https://cloud.google.com/vertex-ai/generative-ai/docs/learn/locations)</td>
      <td>Multiple Azure [regions](https://azure.microsoft.com/en-us/explore/global-infrastructure/products-by-region/)</td>
    </tr>

    <tr>
      <td>Prompt caching</td>
      <td>Enabled by default</td>
      <td>Enabled by default</td>
      <td>Enabled by default</td>
      <td>Enabled by default</td>
      <td>Enabled by default</td>
    </tr>

    <tr>
      <td>Authentication</td>
      <td>Claude.ai SSO or email</td>
      <td>API key</td>
      <td>API key or AWS credentials</td>
      <td>GCP credentials</td>
      <td>API key or Microsoft Entra ID</td>
    </tr>

    <tr>
      <td>Cost tracking</td>
      <td>Usage dashboard</td>
      <td>Usage dashboard</td>
      <td>AWS Cost Explorer</td>
      <td>GCP Billing</td>
      <td>Azure Cost Management</td>
    </tr>

    <tr>
      <td>Includes Claude on web</td>
      <td>Yes</td>
      <td>No</td>
      <td>No</td>
      <td>No</td>
      <td>No</td>
    </tr>

    <tr>
      <td>Enterprise features</td>
      <td>Team management, SSO, usage monitoring</td>
      <td>None</td>
      <td>IAM policies, CloudTrail</td>
      <td>IAM roles, Cloud Audit Logs</td>
      <td>RBAC policies, Azure Monitor</td>
    </tr>
  </tbody>
</table>

Select a deployment option to view setup instructions:

* [Claude for Teams or Enterprise](/en/iam#claude-for-teams-or-enterprise-recommended)
* [Anthropic Console](/en/iam#claude-console-authentication)
* [Amazon Bedrock](../02-Claude-Code-CLI/claude-code-on-amazon-bedrock-claude-code-docs.md)
* [Google Vertex AI](../02-Claude-Code-CLI/claude-code-on-google-vertex-ai-claude-code-docs.md)
* [Microsoft Foundry](../02-Claude-Code-CLI/claude-code-on-microsoft-foundry-claude-code-docs.md)

## Configure proxies and gateways

Most organizations can use a cloud provider directly without additional configuration. However, you may need to configure a corporate proxy or LLM gateway if your organization has specific network or management requirements. These are different configurations that can be used together:

* **Corporate proxy**: Routes traffic through an HTTP/HTTPS proxy. Use this if your organization requires all outbound traffic to pass through a proxy server for security monitoring, compliance, or network policy enforcement. Configure with the `HTTPS_PROXY` or `HTTP_PROXY` environment variables. Learn more in [Enterprise network configuration](../02-Claude-Code-CLI/enterprise-network-configuration-claude-code-docs.md).
* **LLM Gateway**: A service that sits between Claude Code and the cloud provider to handle authentication and routing. Use this if you need centralized usage tracking across teams, custom rate limiting or budgets, or centralized authentication management. Configure with the `ANTHROPIC_BASE_URL`, `ANTHROPIC_BEDROCK_BASE_URL`, or `ANTHROPIC_VERTEX_BASE_URL` environment variables. Learn more in [LLM gateway configuration](../02-Claude-Code-CLI/llm-gateway-configuration-claude-code-docs.md).

The following examples show the environment variables to set in your shell or shell profile (`.bashrc`, `.zshrc`). See [Settings](../02-Claude-Code-CLI/claude-code-settings-claude-code-docs-d4420b4b52.md) for other configuration methods.

### Amazon Bedrock

<Tabs>
  <Tab title="Corporate proxy">
    Route Bedrock traffic through your corporate proxy by setting the following [environment variables](/en/settings#environment-variables):

    ```bash  theme={null}
    # Enable Bedrock
    export CLAUDE_CODE_USE_BEDROCK=1
    export AWS_REGION=us-east-1

    # Configure corporate proxy
    export HTTPS_PROXY='https://proxy.example.com:8080'
    ```
  </Tab>

  <Tab title="LLM Gateway">
    Route Bedrock traffic through your LLM gateway by setting the following [environment variables](/en/settings#environment-variables):

    ```bash  theme={null}
    # Enable Bedrock
    export CLAUDE_CODE_USE_BEDROCK=1

    # Configure LLM gateway
    export ANTHROPIC_BEDROCK_BASE_URL='https://your-llm-gateway.com/bedrock'
    export CLAUDE_CODE_SKIP_BEDROCK_AUTH=1  # If gateway handles AWS auth
    ```
  </Tab>
</Tabs>

### Microsoft Foundry

<Tabs>
  <Tab title="Corporate proxy">
    Route Foundry traffic through your corporate proxy by setting the following [environment variables](/en/settings#environment-variables):

    ```bash  theme={null}
    # Enable Microsoft Foundry
    export CLAUDE_CODE_USE_FOUNDRY=1
    export ANTHROPIC_FOUNDRY_RESOURCE=your-resource
    export ANTHROPIC_FOUNDRY_API_KEY=your-api-key  # Or omit for Entra ID auth

    # Configure corporate proxy
    export HTTPS_PROXY='https://proxy.example.com:8080'
    ```
  </Tab>

  <Tab title="LLM Gateway">
    Route Foundry traffic through your LLM gateway by setting the following [environment variables](/en/settings#environment-variables):

    ```bash  theme={null}
    # Enable Microsoft Foundry
    export CLAUDE_CODE_USE_FOUNDRY=1

    # Configure LLM gateway
    export ANTHROPIC_FOUNDRY_BASE_URL='https://your-llm-gateway.com'
    export CLAUDE_CODE_SKIP_FOUNDRY_AUTH=1  # If gateway handles Azure auth
    ```
  </Tab>
</Tabs>

### Google Vertex AI

<Tabs>
  <Tab title="Corporate proxy">
    Route Vertex AI traffic through your corporate proxy by setting the following [environment variables](/en/settings#environment-variables):

    ```bash  theme={null}
    # Enable Vertex
    export CLAUDE_CODE_USE_VERTEX=1
    export CLOUD_ML_REGION=us-east5
    export ANTHROPIC_VERTEX_PROJECT_ID=your-project-id

    # Configure corporate proxy
    export HTTPS_PROXY='https://proxy.example.com:8080'
    ```
  </Tab>

  <Tab title="LLM Gateway">
    Route Vertex AI traffic through your LLM gateway by setting the following [environment variables](/en/settings#environment-variables):

    ```bash  theme={null}
    # Enable Vertex
    export CLAUDE_CODE_USE_VERTEX=1

    # Configure LLM gateway
    export ANTHROPIC_VERTEX_BASE_URL='https://your-llm-gateway.com/vertex'
    export CLAUDE_CODE_SKIP_VERTEX_AUTH=1  # If gateway handles GCP auth
    ```
  </Tab>
</Tabs>

<Tip>
  Use `/status` in Claude Code to verify your proxy and gateway configuration is applied correctly.
</Tip>

## Best practices for organizations

### Invest in documentation and memory

We strongly recommend investing in documentation so that Claude Code understands your codebase. Organizations can deploy CLAUDE.md files at multiple levels:

* **Organization-wide**: Deploy to system directories like `/Library/Application Support/ClaudeCode/CLAUDE.md` (macOS) for company-wide standards
* **Repository-level**: Create `CLAUDE.md` files in repository roots containing project architecture, build commands, and contribution guidelines. Check these into source control so all users benefit

Learn more in [Memory and CLAUDE.md files](../02-Claude-Code-CLI/how-claude-remembers-your-project-claude-code-docs-f1c064262d.md).

### Simplify deployment

If you have a custom development environment, we find that creating a "one click" way to install Claude Code is key to growing adoption across an organization.

### Start with guided usage

Encourage new users to try Claude Code for codebase Q\&A, or on smaller bug fixes or feature requests. Ask Claude Code to make a plan. Check Claude's suggestions and give feedback if it's off-track. Over time, as users understand this new paradigm better, then they'll be more effective at letting Claude Code run more agentically.

### Configure security policies

Security teams can configure managed permissions for what Claude Code is and is not allowed to do, which cannot be overwritten by local configuration. [Learn more](../02-Claude-Code-CLI/security-claude-code-docs.md).

### Leverage MCP for integrations

MCP is a great way to give Claude Code more information, such as connecting to ticket management systems or error logs. We recommend that one central team configures MCP servers and checks a `.mcp.json` configuration into the codebase so that all users benefit. [Learn more](../06-MCP-Tools/General/connect-claude-code-to-tools-via-mcp-claude-code-docs.md).

At Anthropic, we trust Claude Code to power development across every Anthropic codebase. We hope you enjoy using Claude Code as much as we do.

## Next steps

Once you've chosen a deployment option and configured access for your team:

1. **Roll out to your team**: Share installation instructions and have team members [install Claude Code](advanced-setup-claude-code-docs-0526bc1300.md) and authenticate with their credentials.
2. **Set up shared configuration**: Create a [CLAUDE.md file](../02-Claude-Code-CLI/how-claude-remembers-your-project-claude-code-docs-f1c064262d.md) in your repositories to help Claude Code understand your codebase and coding standards.
3. **Configure permissions**: Review [security settings](../02-Claude-Code-CLI/security-claude-code-docs.md) to define what Claude Code can and cannot do in your environment.