How do I fetch all Git branches?

Question

I cloned a Git repository containing many branches. However, git branch only shows one:

$ git branch
* master

How would I pull all the branches locally so when I do git branch, it shows the following?

$ git branch
* master
* staging
* etc...

Answer 1

TL;DR answer

git branch -r | grep -v '\->' | sed "s,\x1B\[[0-9;]*[a-zA-Z],,g" | while read remote; do git branch --track "${remote#origin/}" "$remote"; done
git fetch --all
git pull --all

(It seems that pull fetches all branches from all remotes, but I always fetch first just to be sure.)

Run the first command only if there are remote branches on the server that aren't tracked by your local branches.

Complete answer

You can fetch all branches from all remotes like this:

git fetch --all

It's basically a power move.

fetch updates local copies of remote branches so this is always safe for your local branches BUT:

1. fetch will not update local branches (which track remote branches); if you want to update your local branches you still need to pull every branch.

2. fetch will not create local branches (which track remote branches), you have to do this manually. If you want to list all remote branches: git branch -a

To update local branches which track remote branches:

git pull --all

However, this can be still insufficient. It will work only for your local branches which track remote branches. To track all remote branches execute this oneliner BEFORE git pull --all:

git branch -r | grep -v '\->' | sed "s,\x1B\[[0-9;]*[a-zA-Z],,g" | while read remote; do git branch --track "${remote#origin/}" "$remote"; done

P.S. AFAIK git fetch --all and git remote update are equivalent.

---

---

Kamil Szot's comment, which folks have found useful.

I had to use:

for remote in `git branch -r`; do git branch --track ${remote#origin/} $remote; done

because your code created local branches named origin/branchname and I was getting "refname 'origin/branchname' is ambiguous whenever I referred to it.

Answer 2

To list remote branches:

git branch -r

To checkout a remote branch as a local branch:

git checkout -b local_branch_name origin/remote_branch_name

Answer 3

You will need to create local branches tracking remote branches.

Assuming that you've got only one remote called origin, this snippet will create local branches for all remote tracking ones:

for b in `git branch -r | grep -v -- '->'`; do git branch --track ${b##origin/} $b; done

After that, git fetch --all will update all local copies of remote branches.

Also, git pull --all will update your local tracking branches, but depending on your local commits and how the 'merge' configure option is set it might create a merge commit, fast-forward or fail.

Answer 4

If you do:

git fetch origin

then they will be all there locally. If you then perform:

git branch -a

you'll see them listed as remotes/origin/branch-name. Since they are there locally you can do whatever you please with them. For example:

git diff origin/branch-name 

or

git merge origin/branch-name

or

git checkout -b some-branch origin/branch-name

Answer 5

$ git remote update
$ git pull --all

This assumes all branches are tracked.

If they aren't you can fire this in Bash:

for remote in `git branch -r `; do git branch --track $remote; done

Then run the command.

Caution: pleas read the warning comments below.

Answer 6

The Bash for loop wasn't working for me, but this did exactly what I wanted. All the branches from my origin mirrored as the same name locally.

git checkout --detach
git fetch origin '+refs/heads/*:refs/heads/*'

See Mike DuPont's comment below. I think I was trying to do this on a Jenkins Server which leaves it in detached head mode.

Answer 7

Use git fetch && git checkout RemoteBranchName.

It works very well for me...

Answer 8

When you clone a repository all the information of the branches is actually downloaded but the branches are hidden. With the command

$ git branch -a

you can show all the branches of the repository, and with the command

$ git checkout -b branchname origin/branchname

you can then "download" them manually one at a time.

---

However, there is a much cleaner and quicker way, though it's a bit complicated. You need three steps to accomplish this:

1. First step

   create a new empty folder on your machine and clone a mirror copy of the .git folder from the repository:

   $ cd ~/Desktop && mkdir my_repo_folder && cd my_repo_folder
   $ git clone --mirror https://github.com/planetoftheweb/responsivebootstrap.git .git
   

   the local repository inside the folder my_repo_folder is still empty, there is just a hidden .git folder now that you can see with a "ls -alt" command from the terminal.

2. Second step

   switch this repository from an empty (bare) repository to a regular repository by switching the boolean value "bare" of the git configurations to false:

   $ git config --bool core.bare false
   

3. Third Step

   Grab everything that inside the current folder and create all the branches on the local machine, therefore making this a normal repo.

   $ git reset --hard
   

So now you can just type the command git branch and you can see that all the branches are downloaded.

This is the quick way in which you can clone a git repository with all the branches at once, but it's not something you wanna do for every single project in this way.

Answer 9

You can fetch all the branches by:

git fetch --all

or:

git fetch origin --depth=10000 $(git ls-remote -h -t origin)

^{The --depth=10000 parameter may help if you've shallowed repository.}

---

To pull all the branches, use:

git pull --all

---

If above won't work, then precede the above command with:

git config remote.origin.fetch '+refs/heads/*:refs/remotes/origin/*'

as the remote.origin.fetch could support only a specific branch while fetching, especially when you cloned your repo with --single-branch. Check this by: git config remote.origin.fetch.

After that you should be able to checkout any branch.

See also:

• How to fetch all remote branches?
• How to clone all remote branches in Git?

---

To push all the branches to the remote, use:

git push --all

eventually --mirror to mirror all refs.

---

If your goal is to duplicate a repository, see: Duplicating a repository article at GitHub.

Answer 10

I usually use nothing else but commands like this:

git fetch origin
git checkout --track origin/remote-branch

A little shorter version:

git fetch origin
git checkout -t origin/remote-branch

Answer 11

If you are here seeking a solution to get all branches and then migrate everything to another Git server, I put together the below process. If you just want to get all the branches updated locally, stop at the first empty line.

git clone <ORIGINAL_ORIGIN>
git branch -r | awk -F'origin/' '!/HEAD|master|main/{print $2 " " $1"origin/"$2}' | xargs -L 1 git branch -f --track 
git fetch --all --prune --tags
git pull --all

git remote set-url origin <NEW_ORIGIN>
git pull
<resolve_any_merge_conflicts>
git push --all
git push --tags
<check_NEW_ORIGIN_to_ensure_it_matches_ORIGINAL_ORIGIN>

Answer 12

You don't see the remote branches because you are not tracking them.

1. Make sure you are tracking all of the remote branches (or whichever ones you want to track).
2. Update your local branches to reflect the remote branches.

---

Track all remote branches:

Track all branches that exist in the remote repo.

Manually do it:

You would replace <branch> with a branch that is displayed from the output of git branch -r.

git branch -r
git branch --track <branch>

Do it with a bash script:

for i in $(git branch -r | grep -vE "HEAD|master"); do git branch --track ${i#*/} $i; done

Lazy way (this can create a mess due to merge conflicts, be careful):

git checkout master
git pull

Update information about the remote branches on your local computer:

This fetches updates on branches from the remote repo which you are tracking in your local repo. This does not alter your local branches. Your local git repo is now aware of things that have happened on the remote repo branches. An example would be that a new commit has been pushed to the remote master, doing a fetch will now alert you that your local master is behind by 1 commit.

git fetch --all

Update information about the remote branches on your local computer and update local branches:

Does a fetch followed by a merge for all branches from the remote to the local branch. An example would be that a new commit has been pushed to the remote master, doing a pull will update your local repo about the changes in the remote branch and then it will merge those changes into your local branch. This can create quite a mess due to merge conflicts.

git pull --all

Answer 13

I believe you have cloned the repository by:

git clone https://github.com/pathOfrepository

Now go to that folder using cd:

cd pathOfrepository

If you type git status you can see all:

   On branch master
Your branch is up-to-date with 'origin/master'.
nothing to commit, working directory clean

To see all hidden branch types:

 git branch -a

It will list all the remote branchs.

Now if you want to checkout on any particular branch just type:

git checkout -b localBranchName origin/RemteBranchName

Answer 14

Make sure all the remote branches are fetchable in .git/config file.

In this example, only the origin/production branch is fetchable, even if you try to do git fetch --all nothing will happen but fetching the production branch:

[origin]
fetch = +refs/heads/production:refs/remotes/origin/production

This line should be replaced by:

[origin]
fetch = +refs/heads/*:refs/remotes/origin/*

Then run git fetch etc...

Answer 15

After you clone the master repository, you just can execute

git fetch && git checkout <branchname>

Answer 16

Just these three commands will get all the branches:

git clone --mirror repo.git  .git     (gets just .git  - bare repository)

git config --bool core.bare false

git reset --hard

Answer 17

How to Fetch All Git Branches Tracking Single Remote.

This has been tested and functions on Red Hat and Git Bash on Windows 10.

---

TLDR:

for branch in `git branch -r|grep -v ' -> '|cut -d"/" -f2`; do git checkout $branch; git fetch; done;

Explanation:

The one liner checks out and then fetches all branches except HEAD.

List the remote-tracking branches.

git branch -r

Ignore HEAD.

grep -v ' -> '

Take branch name off of remote(s).

cut -d"/" -f2

Checkout all branches tracking a single remote.

git checkout $branch

Fetch for checked out branch.

git fetch

---

Technically the fetch is not needed for new local branches.

This may be used to either fetch or pull branches that are both new and have changes in remote(s).

Just make sure that you only pull if you are ready to merge.

---

Test Setup

Check out a repository with SSH URL.

git clone git@repository.git

Before

Check branches in local.

$ git branch
* master

Execute Commands

Execute the one liner.

for branch in `git branch -r|grep -v ' -> '|cut -d"/" -f2`; do git checkout $branch; git fetch; done;

After

Check local branches include remote(s) branches.

$ git branch
  cicd
  master
* preprod

Answer 18

Looping didn't seem to work for me and I wanted to ignore origin/master. Here's what worked for me.

git branch -r | grep -v HEAD | awk -F'/' '{print $2 " " $1"/"$2}' | xargs -L 1 git branch -f --track

After that:

git fetch --all
git pull --all

Answer 19

For Windows users using PowerShell:

git branch -r | ForEach-Object {
    # Skip default branch, this script assumes
    # you already checked-out that branch when cloned the repo
    if (-not ($_ -match " -> ")) {
        $localBranch = ($_ -replace "^.*?/", "")
        $remoteBranch = $_.Trim()
        git branch --track "$localBranch" "$remoteBranch"
    }
}; git fetch --all; git pull --all

Answer 20

Here's something I'd consider robust:

• Doesn't update remote tracking for existing branches
• Doesn't try to update HEAD to track origin/HEAD
• Allows remotes named other than origin
• Properly shell quoted

for b in $(git branch -r --format='%(refname:short)'); do
  [[ "${b#*/}" = HEAD ]] && continue
  git show-ref -q --heads "${b#*/}" || git branch --track "${b#*/}" "$b";
done
git pull --all

It's not necessary to git fetch --all as passing -all to git pull passes this option to the internal fetch.

Credit to this answer.

Answer 21

Be careful while playing with git, go step by step.

$ git remote update  //This will update your local
$ git branch -a      //This will list all the branches(After updating you can now 
see the new branch in the list)
$ git checkout your_branch_name

Answer 22

Set alias: (based on the top answer)

git config --global alias.track-all-branches '!git fetch --all && for remote in `git branch -r`; do git branch --track ${remote#origin/} $remote; done && git fetch --all'

Now to track all the branches:

git track-all-branches

Answer 23

|‾‾‾‾‾‾‾‾‾‾‾‾‾fetch/clone‾‾‾‾‾‾‾‾‾‾‾‾↓   |‾‾‾‾‾‾‾‾‾‾‾‾checkout‾‾‾‾‾‾‾‾‾‾↓   
|‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾pull‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾↓
Remote repository (`origin`) <=> Local repository <=> Index <=> Workspace
↑_________________push_______________|   ↑____commit____|  ↑____add_____| 

# 拉取远程仓库所有分支信息 → 本地仓库
# fetch all remote repository branch meta → local repository
git remote set-branches origin '*'
git fetch -v

# 把所有远程分支数据搞到本地
# fetch all remote repository branch data → local repository
git branch -r | grep -v '\->' | while read remote; do git branch "${remote#origin/}" "$remote"; done
git fetch --all
git pull --all

Answer 24

you can fetch all braches by this one line command like this:

git fetch --all && git pull --all && git branch -r | grep -v '\->' | while read remote; do git branch --track "${remote#origin/}" "$remote"; done

Answer 25

I wrote a little script to manage cloning a new repo and making local branches for all the remote branches.

You can find the latest version here:

#!/bin/bash

# Clones as usual but creates local tracking branches for all remote branches.
# To use, copy this file into the same directory your git binaries are (git, git-flow, git-subtree, etc)

clone_output=$((git clone "$@" ) 2>&1)
retval=$?
echo $clone_output
if [[ $retval != 0 ]] ; then
    exit 1
fi
pushd $(echo $clone_output | head -1 | sed 's/Cloning into .\(.*\).\.\.\./\1/') > /dev/null 2>&1
this_branch=$(git branch | sed 's/^..//')
for i in $(git branch -r | grep -v HEAD); do
  branch=$(echo $i | perl -pe 's/^.*?\///')
  # this doesn't have to be done for each branch, but that's how I did it.
  remote=$(echo $i | sed 's/\/.*//')
  if [[ "$this_branch" != "$branch" ]]; then
      git branch -t $branch $remote/$branch
  fi
done
popd > /dev/null 2>&1

To use it, just copy it into your git bin directory (for me, that’s C:\Program Files (x86)\Git\bin\git-cloneall), then, on the command line:

git cloneall [standard-clone-options] <url>

It clones as usual, but creates local tracking branches for all remote branches.

Answer 26

If you have problems with fetch --all then track your remote branch:

git checkout --track origin/%branchname%

Answer 27

We can put all branch or tag names in a temporary file, then do git pull for each name/tag:

git branch -r | grep origin | grep -v HEAD| awk -F/ '{print $NF}' > /tmp/all.txt
git tag -l >> /tmp/all.txt
for tag_or_branch in `cat /tmp/all.txt`; do git checkout $tag_or_branch; git pull origin $tag_or_branch; done

Answer 28

Have tried many ways, only this one is simple and works for me.

for branch in $(git ls-remote -h git@<your_repository>.git | awk '{print $2}' | sed 's:refs/heads/::')
do
  git checkout "$branch"
  git pull
done

Answer 29

TLDR It is likely a bad idea to create a local branch for each remote tracking branch. These different types of branches serve different purposes and local branches are normally created based on their need. git branch shows local branches git branch -r shows the remote tracking branches. git branch -a shows both. You can update all remote tracking branches with an appropriate fetch command. That should usually be all you need.

---

After scrolling through the existing answers I see two kinds: those simply answering the question asked, rather than suggesting a different approach. And those suggesting a different approach without explaining why. Here is my attempt to explain a bit more.

There are actually three kinds of branches a usual git repository needs to deal with. These three kinds of branches serve different purposes. In short:

• remote branches: These are the branches as they exist in the remote repository. You will never read from remote branches directly. All reading of remote branches happens through gits so called "remote tracking branches"

• remote tracking branches: git keeps local snapshots of the remote branches which are most accurately called "remote tracking branches". They are updated when you call git fetch or git pull (which does a fetch). You can often get away with using the remote tracking branches without creating local branches out of them.

  For example:

  git merge origin/master
  

  will merge the remote tracking branch origin/master into the current local branch without requiring you to create a local copy of it first. This means: there is a remote tracking branch called origin/master which is a snapshot of the branch called master as it exists on the remote repository called origin. And this command will merge it into the current checked-out local branch. You may want to do a fetch before performing operations like this.

• local branches: these are manually created snapshots of certain points in history (often based on remote tracking branches, at least at first). They are much more static than the other kinds and will really only change when you manually change them. One by one. You will likely want a local branch if you want to view its contents in your working-tree (project directory) or when you want to add commits to it.

Once you are done with a local branch (and published its contents) you may consider deleting it. That way you do not need to keep it up to date. After all, a fetch will not update the current local branch, and a pull will only update the current checked-out local branch. In other words: you should only create local branches when you need them, and you should probably delete them when you no longer do.

It is probably not accurate to say that 'some branches are hidden by default'. Rather the git branch command was created to show you the "local branches". You can use git branch -r to list the remote tracking branches and git branch -a to show both the local branches and the remote tracking branches. These two different types of branches serve a different purpose and you are not likely to need a local branch for each remote tracking one.

Also note that is is generally a bad idea to create local branches whose names begin with the name of a remote followed by a slash (eg creating a local branch called "origin/master" tends to be a bad idea since its name conflicts with the name of the remote tracking branch).

In the context of updating branches, it does make sense to discuss different flavours of fetch commands:

• git fetch: updates only the remote tracking branches whose remote matches the one used in the "upstream" of the current checked out branch. If the checked out branch does not have an upstream set, this falls back to fetching from a remote called "origin" if it exists. This command is the easiest, and is sufficient most of the time.
• git fetch --all: updates all remote tracking branches regardless of the remote they belong are snapshotting from.

I am especially fond of

git fetch -tf --all

Which will also always update (and override if needed) all tags, including tags not reachable from the remote branches.

Answer 30

Here's a Perl version of the one-liner provided in the accepted answer:

git branch -r | perl -e 'while(<>) {chop; my $remote = $_; my ($local) = ($remote =~ /origin\/(.*)/); print "git branch --track $local $remote\n";}' > some-output-file

You can run the output file as a Shell script if you'd like.

We deleted our Stash project repository by accident. Fortunately someone had created a fork right before the accidental loss. I cloned the fork to my local (will omit the details of how I did that). Once I had the fork fully in my local, I ran one one-liner. I modified the remote's URL (origin in my case) to point to the target repository we were recovering to:

git remote set-url origin <remote-url>

And finally pushed all branches to origin like so:

git push --all origin

and we were back in business.

Answer 31

To avoid the error message 'fatal: A branch named 'origin/master' already exists.', you may try my solution:

git branch -r | grep -v '\->'  | grep -v `git branch | awk '/\*/ { print $2; }'`| while read remote; do git branch --track "${remote#origin/}" "$remote"; done

Answer 32

Based on the answer by Learath2, here's what I did after doing git clone [...] and cd-ing into the created directory:

git branch -r | grep -v master | awk {print\$1} | sed 's/^origin\/\(.*\)$/\1 &/' | xargs -n2 git checkout -b

Worked for me but I can't know it'll work for you. Be careful.

Answer 33

git remote add origin https://yourBitbucketLink

git fetch origin

git checkout -b yourNewLocalBranchName origin/requiredRemoteBranch (use tab :D)

Now locally your yourNewLocalBranchName is your requiredRemoteBranch.

Answer 34

For Visual Studio Users, On Package Manager console:

git branch | %{ git fetch upstream; git merge upstream/master}