8700

Somebody pushed a branch called test with git push origin test to a shared repository. I can see the branch with git branch -r. How do I check out the remote test branch? I've tried:

  • git checkout test, which does nothing
  • git checkout origin/test gives * (no branch)
10
  • 66
    I feel like I'm taking crazy pills. I'm trying to checkout a branch from an upstream, not just origin, and every recommended answer doesn't do anything remotely helpful (pun-intended). EDIT - excuse me, the multitude of suggestions contained in the top 2 answers were useless; 3rd one (git branch test origin/test) is what works. Glad the top 2 have 20x the number of votes...
    – dwanderson
    Commented Mar 9, 2017 at 16:35
  • Maybe useful to someone else: When I used the Atom editor UI to fetch and pull changes, it pulled changes on the "main" branch but did not create a local reference to the second remote branch. Using git fetch on the command line created that reference, then I was able to checkout the branch as per several answers.
    – Emma Leis
    Commented Nov 15, 2021 at 5:19
  • 10
    git fetch then git switch
    – onmyway133
    Commented Apr 25, 2022 at 11:34
  • 1
    At least in modern (2022) git context, git fetch origin test would be a necessary command before git checkout origin/test. Commented May 6, 2022 at 19:19
  • 5
    This answer should be archived. It's not useful to show people answers this old. Stackoverflow should have an updated answer button.
    – NickJ
    Commented May 31, 2022 at 2:46

44 Answers 44

11721

The answer has been split depending on whether there is one remote repository configured or multiple. The reason for this is that for the single remote case, some of the commands can be simplified as there is less ambiguity.

Updated for Git 2.23: For older versions, see the section at the end.

With One Remote

In both cases, start by fetching from the remote repository to make sure you have all the latest changes downloaded.

$ git fetch

This will fetch all of the remote branches for you. You can see the branches available for checkout with:

$ git branch -v -a

...
remotes/origin/test

The branches that start with remotes/* can be thought of as read only copies of the remote branches. To work on a branch you need to create a local branch from it. This is done with the Git command switch (since Git 2.23) by giving it the name of the remote branch (minus the remote name):

$ git switch test

In this case Git is guessing (can be disabled with --no-guess) that you are trying to checkout and track the remote branch with the same name.

With Multiple Remotes

In the case where multiple remote repositories exist, the remote repository needs to be explicitly named.

As before, start by fetching the latest remote changes:

$ git fetch origin

This will fetch all of the remote branches for you. You can see the branches available for checkout with:

$ git branch -v -a

With the remote branches in hand, you now need to check out the branch you are interested in with -c to create a new local branch:

$ git switch -c test origin/test

For more information about using git switch:

$ man git-switch

Prior to Git 2.23

git switch was added in Git 2.23, prior to this git checkout was used to switch branches.

To checkout out with only a single remote repository:

git checkout test

if there are multiple remote repositories configured then it becomes a bit longer

git checkout -b test <name of remote>/test
12
  • 487
    To expand on this: git doesn't allow you to work on someone else's branches. You can only work on your own. So if you want to add to someone else's branch, you need to create your own "copy" of that branch, which is what the above command does (well, it creates your branch and checks it out, too). Commented Nov 23, 2009 at 15:24
  • 161
    If it's a new remote branch you may need to git fetch before doing this so that git is aware of origin/test Commented Nov 4, 2011 at 14:38
  • 65
    ...and you would do this with git fetch origin test
    – Andrew
    Commented Jan 22, 2012 at 23:24
  • 23
    Error: "git checkout: updating paths is incompatible with switching branches. Did you intend to checkout origin/test which can not be resolved as commit?"
    – Xeoncross
    Commented Sep 11, 2012 at 20:35
  • 95
    git checkout test will NOT work in modern git if you have multiple remotes which have the same branch name. It can't know which one to use.
    – masukomi
    Commented Sep 16, 2014 at 15:34
1534

Sidenote: With modern Git (>= 1.6.6), you are able to use just

git checkout test

(note that it is 'test' not 'origin/test') to perform magical DWIM-mery and create local branch 'test' for you, for which upstream would be remote-tracking branch 'origin/test'.


The * (no branch) in git branch output means that you are on unnamed branch, in so called "detached HEAD" state (HEAD points directly to commit, and is not symbolic reference to some local branch). If you made some commits on this unnamed branch, you can always create local branch off current commit:

git checkout -b test HEAD

A more modern approach as suggested in the comments:

@Dennis: git checkout <non-branch>, for example git checkout origin/test results in detached HEAD / unnamed branch, while git checkout test or git checkout -b test origin/test results in local branch test (with remote-tracking branch origin/test as upstream) – Jakub Narębski Jan 9 '14 at 8:17

emphasis on git checkout origin/test

6
  • 39
    Unsurprising, but this version has been released in the last few years - knowing this syntax can save a lot of time since there's still a lot of old documentation and comment threads floating around that suggest the older method for doing this.
    – Curtis
    Commented Apr 16, 2012 at 13:24
  • 13
    "modern git"--for the record, (approx) what version are you referring to? Sometimes we have to work on systems running older distros. Commented Aug 28, 2012 at 2:30
  • 14
    @aidan If you get a response like error: pathspec 'branch_name' did not match any file(s) known to git. then you should do a git fetch first.
    – Dennis
    Commented Oct 18, 2013 at 0:40
  • 6
    Using git version 1.8.3.msysgit.0 and this doesn't work for me - did not match any file(s) known to git - I've done many git fetches
    – PandaWood
    Commented Dec 3, 2013 at 23:59
  • 14
    @Dennis: git checkout <non-branch>, for example git checkout origin/test results in detached HEAD / unnamed branch, while git checkout test or git checkout -b test origin/test results in local branch test (with remote-tracking branch origin/test as upstream) Commented Jan 9, 2014 at 8:17
802

In this case, you probably want to create a local test branch which is tracking the remote test branch:

$ git branch test origin/test

In earlier versions of git, you needed an explicit --track option, but that is the default now when you are branching off a remote branch.

To create the local branch and switch to it, use:

$ git checkout -b test origin/test
2
  • 2
    In your bash git checkout -b test/origin/test suggestion above, you made want to precede it with a bash git fetch upstream to insure that your local repository knows the remote branch test is there. Otherwise, thanks, everything works as advertised. Commented Apr 20, 2022 at 17:14
  • This is what I was actually trying to accomplish. When I used the other commands I wound up in a detached HEAD state which is not what I was looking for. Thanks!
    – Dominic P
    Commented Jul 10, 2023 at 22:09
580

Accepted answer not working for you?

While the first and selected answer is technically correct, there's the possibility you have not yet retrieved all objects and refs from the remote repository. If that is the case, you'll receive the following error:

$ git checkout -b remote_branch origin/remote_branch

fatal: git checkout: updating paths is incompatible with switching branches.
Did you intend to checkout 'origin/remote_branch' which can not be resolved as commit?

Solution

If you receive this message, you must first do a git fetch origin where origin is the name of the remote repository prior to running git checkout remote_branch. Here's a full example with responses:

$ git fetch origin
remote: Counting objects: 140, done.
remote: Compressing objects: 100% (30/30), done.
remote: Total 69 (delta 36), reused 66 (delta 33)
Unpacking objects: 100% (69/69), done.
From https://github.com/githubuser/repo-name
   e6ef1e0..5029161  develop    -> origin/develop
 * [new branch]      demo       -> origin/demo
   d80f8d7..359eab0  master     -> origin/master

$ git checkout demo
Branch demo set up to track remote branch demo from origin.
Switched to a new branch 'demo'

As you can see, running git fetch origin retrieved any remote branches we were not yet setup to track on our local machine. From there, since we now have a ref to the remote branch, we can simply run git checkout remote_branch and we'll gain the benefits of remote tracking.

0
414

I tried the above solution, but it didn't work. Try this, it works:

git fetch origin 'remote_branch':'local_branch_name'

This will fetch the remote branch and create a new local branch (if not exists already) with name local_branch_name and track the remote one in it.

8
  • 55
    This worked for me when neither git fetch origin or git remote update created local branches. I'm not sure why.
    – Godsmith
    Commented Sep 11, 2014 at 8:45
  • 11
    This was the most direct way to accomplish what I needed which was to use a remote branch (not master) to create a new branch.
    – Roralee
    Commented Nov 13, 2015 at 23:15
  • 11
    this worked for me too, where accepted answers and other high voted didn't. My git version is 2.5.0
    – pdepmcp
    Commented Feb 17, 2017 at 12:46
  • 5
    I had a branch of that form: "xx/xx" and This was the solution for me.
    – User
    Commented Mar 14, 2017 at 8:50
  • 14
    Does anyone have any idea why this works when everything else doesn't? (I'm on git 2.13.0) Commented Jun 19, 2017 at 18:43
139

You basically see the branch, but you don't have a local copy of that yet!...

You need to fetch the branch...

You can simply fetch and then checkout to the branch, use the one line command below to do that:

git fetch && git checkout test

I also created the image below for you to share the differences, look at how fetch works and also how it's different to pull:

git fetch

0
126

Use:

git checkout -b <BRANCH-NAME> <REMOTE-NAME>/<BRANCH-NAME>

Other answers do not work with modern Git in my benign case. You might need to pull first if the remote branch is new, but I haven't checked that case.

2
  • 15
    Looking at it now, they do overlap. Only mine is succinct and tells you what to do rather than tell a story. I assume it can be more useful therefore, especially for nowadays git versions. You can downvote it if you think it is a bad answer.
    – matanox
    Commented Feb 21, 2016 at 11:34
  • 1
    After reading the other answers and getting more and more confused, this is the one that actually worked for me :)
    – RosieC
    Commented Jul 25, 2023 at 13:22
125

This will DWIM for a remote not named origin (documentation):

$ git checkout -t remote_name/remote_branch

To add a new remote, you will need to do the following first:

$ git remote add remote_name location_of_remote
$ git fetch remote_name

The first tells Git the remote exists, the second gets the commits.

0
78

To clone a Git repository, do:

git clone <either ssh url /http url>

The above command checks out all of the branches, but only the master branch will be initialized. If you want to checkout the other branches, do:

git checkout -t origin/future_branch (for example)

This command checks out the remote branch, and your local branch name will be same as the remote branch.

If you want to override your local branch name on checkout:

git checkout -t -b enhancement origin/future_branch

Now your local branch name is enhancement, but your remote branch name is future_branch.

0
74

I always do:

git fetch origin && git checkout --track origin/branch_name

0
50

I was stuck in a situation seeing error: pathspec 'desired-branch' did not match any file(s) known to git. for all of the suggestions above. I'm on Git version 1.8.3.1.

So this worked for me:

git fetch origin desired-branch
git checkout -b desired-branch FETCH_HEAD

The explanation behind is that I've noticed that when fetching the remote branch, it was fetched to FETCH_HEAD:

git fetch origin desired-branch

From github.com:MYTEAM/my-repo
    * branch            desired-branch -> FETCH_HEAD
3
  • I had the same problem when trying to check out the remote branch in a submodule in a worktree. Anyone knows what's the reason for that? Commented Mar 18, 2022 at 8:20
  • This is very useful if some of the branches are very big, and you don't necessarily want to download them all.
    – ninpnin
    Commented Jan 23, 2023 at 11:27
  • This fixed it for me when I was trying to locally checkout a branch in the upstream repo, but the situation was so strange. Normally I can fetch all the upstream branches with a simple git fetch upstream, but this wasn't working. So I specifically named the branch I wanted, which resulted in it writing to FETCH_HEAD. I've never seen this before. I'm using Git 2.43.0. I did clone the repo using gh-cli, so maybe that affects the behavior of git fetch?? Commented Feb 12 at 19:19
48

You can try

git fetch remote
git checkout --track -b local_branch_name origin/branch_name

or

git fetch
git checkout -b local_branch_name origin/branch_name
2
  • 4
    FYI, --track is no longer needed in newer versions of git, because it's set by default, as explained in this earlier answer.
    – user456814
    Commented Jun 21, 2014 at 18:03
  • This comment worked for me, thank you! git checkout -b local_branch_name origin/branch_name
    – Tim Kelly
    Commented Sep 15, 2021 at 23:39
41

First, you need to do:

git fetch # If you don't know about branch name

git fetch origin branch_name

Second, you can check out remote branch into your local by:

git checkout -b branch_name origin/branch_name

-b will create new branch in specified name from your selected remote branch.

1
  • This has never worked for me. I getting an error telling me <remote branch name> is not a commit and <local branch name> cannot be created from it.
    – Jimbo
    Commented Feb 9, 2022 at 17:07
36

I use the following command:

git checkout --track origin/other_remote_branch
1
  • 15
    This answer would be a lot more useful if you explain why you are using it this way. i.e. why someone should use '--track' and so on... Commented Nov 20, 2017 at 3:19
36

The git remote show <origin name> command will list all branches (including un-tracked branches). Then you can find the remote branch name that you need to fetch.

Example:

git remote show origin

Use these steps to fetch remote branches:

git fetch <origin name> <remote branch name>:<local branch name>
git checkout <local branch name > (local branch name should the name that you given fetching)

Example:

git fetch origin test:test
git checkout test
3
  • 1
    Good lord, thank you. Been using git for a decade but was on a giant repo drowning all the sudden, just trying to check out a branch... This got me going!
    – swajak
    Commented Sep 30, 2021 at 14:22
  • 1
    Best answer for me Commented Oct 26, 2022 at 5:05
  • 1
    I prefer this because I don't have to fetch all branches from the remote, just the one I want. Commented Mar 29, 2023 at 17:23
31

Commands

git fetch --all
git checkout -b <ur_new_local_branch_name> origin/<Remote_Branch_Name>

are equal to

 git fetch --all

and then

 git checkout -b fixes_for_dev origin/development

Both will create a latest fixes_for_dev from development

31

Simply run git checkout with the name of the remote branch. Git will automatically create a local branch that tracks the remote one:

git fetch
git checkout test

However, if that branch name is found in more than one remote, this won't work as Git doesn't know which to use. In that case you can use either:

git checkout --track origin/test

or

git checkout -b test origin/test

In 2.19, Git learned the checkout.defaultRemote configuration, which specifies a remote to default to when resolving such an ambiguity.

26

There are many alternatives, for example:

  • Alternative 1:

    git fetch && git checkout test
    

    It's the simplest way.

  • Alternative 2:

    git fetch
    git checkout test
    

    It's the same, but in two steps.

1
25

None of these answers worked for me. This worked:

git checkout -b feature/branch remotes/origin/feature/branch
0
24

If the branch is on something other than the origin remote I like to do the following:

$ git fetch
$ git checkout -b second/next upstream/next

This will checkout the next branch on the upstream remote in to a local branch called second/next. Which means if you already have a local branch named next it will not conflict.

$ git branch -a
* second/next
  remotes/origin/next
  remotes/upstream/next
22

git fetch && git checkout your-branch-name

2
  • How does this magic work? Commented Sep 6, 2022 at 11:25
  • @PeterMortensen There are two commands, git fetch fetches all information from remove and it also fetches the latest branches available. Then git checkout your-branch-name checkouts the branch Commented Sep 7, 2022 at 16:07
17

git branch -r says the object name is invalid, because that branch name isn't in Git's local branch list. Update your local branch list from origin with:

git remote update

And then try checking out your remote branch again.

This worked for me.

I believe git fetch pulls in all remote branches, which is not what the original poster wanted.

1
  • 2
    FYI, git remote update will also fetch all remote branches.
    – user456814
    Commented Jun 21, 2014 at 17:59
17

TL;DR

Using git switch rather than git checkout. More details are on this page.

I think the answer is obsolete. Git split some functions of checkout to switch and restore now.

The following is my summary:

If you want to update something for a remote branch, you should create a local branch to "track" the remote branch. You can update anything you want in local and finally push to remote. If you check out to the remote branch directly after cloning your repository, you may see the "detached HEAD" status and the following message from Git:

Note: switching to 'origin/asd'.

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by switching back to a branch.

If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -c with the switch command. Example:

  git switch -c <new-branch-name>

Or undo this operation with:

  git switch -

Turn off this advice by setting config variable advice.detachedHead to false

HEAD is now at d3e1083 Update a

So how can we create a local branch to track a remote branch?

To create a local branch to track a remote branch, you can use git checkout <remote branch name> or git switch <remote branch name>. If you have a file or folder has same name as your remote branch name, git checkout would output some error message, but git switch can work normally!

Example:

  1. See all branches, and we want to create a local branch to track the remote branch remotes/origin/asd, and we also have the file name asd:

    $ git branch -a
    * master
      remotes/origin/HEAD -> origin/master
      remotes/origin/asd
      remotes/origin/ereres
      remotes/origin/master
      remotes/origin/zxc
    $ ls
    a  asd
    
  2. The filename is same as remote branch, and Git should output some error messages if we are using the git checkout command to create a local branch to track a remote branch

    $ git checkout asd
    fatal: 'asd' could be both a local file and a tracking branch.
    Please use -- (and optionally --no-guess) to disambiguate
    
  3. It works if we are using git switch!

    $ git switch ereres
    Branch 'ereres' set up to track remote branch 'ereres' from 'origin'.
    Switched to a new branch 'ereres'
    
    $ git branch -vv
    * ereres 3895036 [origin/ereres] Update a
      master f9e24a9 [origin/master] Merge branch 'master' of
    
4
  • not work with 2.17.1, no command found for "git switch" . @hallski 's answer works for me!
    – Siwei
    Commented Sep 24, 2021 at 2:16
  • @Siwei No command since your Git version < 2.23. You can refer to this link to see more details.
    – chilin
    Commented Sep 25, 2021 at 3:37
  • Re "the answer is obsolete": What answer? The accepted answer? Several answers? Which ones? Commented Sep 6, 2022 at 11:27
  • The accepted answer, but the accepted answer already updated for Git 2.23 at Dec 19, 2021.
    – chilin
    Commented Sep 7, 2022 at 4:02
15

Fetch from the remote and checkout the branch.

git fetch <remote_name> && git checkout <branch_name> 

E.g.:

git fetch origin && git checkout feature/XYZ-1234-Add-alerts

0
14

Other guys and gals give the solutions, but maybe I can tell you why.

git checkout test which does nothing

Does nothing doesn't equal doesn't work, so I guess when you type 'git checkout test' in your terminal and press enter key, no message appears and no error occurs. Am I right?

If the answer is 'yes', I can tell you the cause.

The cause is that there is a file (or folder) named 'test' in your work tree.

When git checkout xxx parsed,

  1. Git looks on xxx as a branch name at first, but there isn't any branch named test.
  2. Then Git thinks xxx is a path, and fortunately (or unfortunately), there is a file named test. So git checkout xxx means discard any modification in xxx file.
  3. If there isn't file named xxx either, then Git will try to create the xxx according to some rules. One of the rules is create a branch named xxx if remotes/origin/xxx exists.
0
14

To get newly created branches

git fetch

To switch into another branch

git checkout BranchName
14

git checkout -b "Branch_name" [ B means Create local branch]

git branch --all

git checkout -b "Your Branch name"

git branch

git pull origin "Your Branch name"

successfully checkout from the master branch to dev branch

enter image description here

0
14

To get all remote branches, use this:

git fetch --all

Then check out to the branch:

git checkout test
0
13

It seems to my that no one suggested the simplest way (or maybe I'm too dumb to think this is "a way"). But anyway, try this:

git pull origin remoteBranchName
git switch remoteBranchName

This worked for me in the same case (a branch created on the remote after my last pull request).

12

For us, it seems the remote.origin.fetch configuration gave a problem. Therefore, we could not see any other remote branches than master, so git fetch [--all] did not help. Neither git checkout mybranch nor git checkout -b mybranch --track origin/mybranch did work, although it certainly was at remote.

The previous configuration only allowed master to be fetched:

$ git config --list | grep fetch
remote.origin.fetch=+refs/heads/master:refs/remotes/origin/master

Fix it by using * and fetch the new information from origin:

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

$ git fetch
...
 * [new branch] ...
...

Now we could git checkout the remote branch locally.

I don't have any idea how this configuration ended up in our local repository.

0

Not the answer you're looking for? Browse other questions tagged or ask your own question.