How to Check Out a Remote Git Branch

When collaborating on projects, you'll often need to work with branches that other developers have created on the remote repository. These remote branches don't automatically appear in your local repository, so you need to explicitly check them out to work with them.

In this guide, you'll learn several methods to check out remote Git branches and start working with code from other team members.

Prerequisites

You'll need Git installed and access to a repository with remote branches. Basic familiarity with Git branching concepts will help you understand when and why to check out remote branches.

Understanding Remote Branches

Remote branches are references to the state of branches in your remote repositories. When you clone a repository or fetch updates, Git downloads information about these branches but doesn't automatically create local versions of them.

To see all available branches, including remote ones:

git branch -a

This shows output like:

* main
  remotes/origin/main
  remotes/origin/feature/user-authentication
  remotes/origin/hotfix/security-patch

The branches prefixed with remotes/origin/ are remote branches that exist on the server but don't have local counterparts yet.

Method 1: Using git checkout (Traditional Method)

The traditional way to check out a remote branch creates a local branch that tracks the remote branch:

git checkout -b feature/user-authentication origin/feature/user-authentication

This command creates a new local branch called feature/user-authentication based on the remote branch origin/feature/user-authentication. The -b flag creates a new branch and switches to it in one command.

If the local branch name matches the remote branch name exactly, Git provides a shortcut:

git checkout feature/user-authentication

Git automatically recognizes that you want to create a local branch tracking the remote branch with the same name.

Method 2: Using git switch (Modern Method)

Git version 2.23 introduced the git switch command, which provides a clearer syntax for branch operations:

git switch -c feature/user-authentication origin/feature/user-authentication

The -c flag creates a new branch and switches to it, similar to checkout -b.

For branches with matching names, you can use the simpler form:

git switch feature/user-authentication

Git automatically sets up tracking between your local branch and the remote branch.

Method 3: Fetch and Checkout

Sometimes you need to fetch the latest remote information before checking out a branch:

# First, fetch all remote branches
git fetch origin

# Then checkout the specific branch
git checkout feature/user-authentication

This ensures you have the most recent information about remote branches before creating your local copy.

Checking Available Remote Branches

Before checking out a remote branch, you might want to see what's available:

# See all remote branches
git branch -r

# See detailed information about remote branches
git branch -rv

The -v flag shows the last commit on each branch, helping you understand what each branch contains.

You can also list branches with specific patterns:

# Show only feature branches
git branch -r | grep feature

# Show branches from a specific remote
git branch -r | grep origin

Setting Up Branch Tracking

When you check out a remote branch, Git automatically sets up tracking so your local branch knows about its remote counterpart. You can verify this setup:

git branch -vv

This shows which remote branch each local branch tracks:

  feature/user-authentication a1b2c3d [origin/feature/user-authentication] Add login form
* main                        e4f5g6h [origin/main] Update README

The text in brackets shows the remote tracking branch.

Working with Multiple Remotes

If your repository has multiple remotes, you need to specify which remote contains the branch you want:

# Check out branch from origin remote
git checkout -b feature/api-updates origin/feature/api-updates

# Check out branch from upstream remote
git checkout -b feature/api-updates upstream/feature/api-updates

First, list your remotes to see what's available:

git remote -v

Handling Branch Name Conflicts

If you already have a local branch with the same name as the remote branch you want to check out:

# This will fail if local branch already exists
git checkout feature/user-authentication
# fatal: A branch named 'feature/user-authentication' already exists.

# Force checkout, replacing local branch
git checkout -B feature/user-authentication origin/feature/user-authentication

The -B flag creates a new branch or resets an existing branch to the specified commit.

Pulling Changes After Checkout

After checking out a remote branch, you can pull the latest changes:

git checkout feature/user-authentication
git pull origin feature/user-authentication

Since tracking is set up automatically, you can also use the shorter form:

git pull

Common Workflows

Collaborating on Feature Branches

When a teammate creates a feature branch and you need to contribute:

# Fetch latest remote information
git fetch origin

# Check out their feature branch
git checkout feature/user-authentication

# Make your changes and push them
git add .
git commit -m "Add password validation"
git push origin feature/user-authentication

Reviewing Pull Requests

To test someone's pull request locally:

# Check out the branch from the pull request
git fetch origin
git checkout feature/new-dashboard

# Test the changes
npm test
npm start

# Switch back to main when done
git checkout main

Working with Release Branches

When checking out release branches for bug fixes:

# Check out the release branch
git checkout release/v2.1

# Create a hotfix branch from it
git checkout -b hotfix/critical-security-fix

# Make your fixes and push
git add .
git commit -m "Fix security vulnerability"
git push origin hotfix/critical-security-fix

Cleaning Up After Remote Branches Are Deleted

When remote branches are deleted (after merging pull requests), your local repository still has references to them:

# Remove references to deleted remote branches
git remote prune origin

# Or use fetch with prune
git fetch --prune origin

This cleans up your local references to remote branches that no longer exist.

Best Practices

Always fetch before checking out remote branches to ensure you have the latest information:

git fetch origin && git checkout feature/new-feature

Use descriptive branch names that match the remote branches to avoid confusion.

Set up your Git configuration to always set up tracking for new branches:

git config --global branch.autosetupmerge always
git config --global branch.autosetuprebase always

Regularly clean up local branches that are no longer needed after remote branches are deleted:

# List merged branches
git branch --merged main

# Delete local branches that have been merged
git branch -d feature/completed-feature

Understanding how to check out remote branches is essential for collaborative development. Whether you use the traditional git checkout or the modern git switch command, you now have the tools to work with any branch your team creates on the remote repository.