Make an existing Git branch track a remote branch?

Question

I know how to make a new branch that tracks remote branches, but how do I make an existing branch track a remote branch?

I know I can just edit the .git/config file, but it seems there should be an easier way.

Robb

As noted below, for an existing branch, you can use git push -u origin branch-name. – Militiaman

If local branch is current branch, and local branch is not already tracking a remote, git pull will often provide helpful messages about the appropriate command to set tracking information – Blake

It's annoying when one is learning git to be shown a link to the git documentation. That documentation appears to be written for people that already know what they are doing with git. – Cotton

as of Git 2.10 you should first checkout to intended local branch and then do this git branch --set-upstream-to origin/<branch> – Misconstruction

--set-upstream produces an error: fatal: the '--set-upstream' option is no longer supported. Please use '--track' or '--set-upstream-to' instead. so git branch --set-upstream-to origin/<branch name> is the current command that works. – Outclass

For people getting this SO question as first hit searching for "git remote add" "tracking": I needed to add a new remote tracking an existing branch, which I solved with git remote add gitlab https://[email protected]/group/subgroup/repository.git -t master followed by git push gitlab. Works with git version 2.18.0. The -t is for tracking as there is no --tracking according to man git remote add – Uric

it is definitely frustrating that checking out out a branch or initiating gitflow intermittently does not link the branch to the remote source and will randomly throw errors instead of completing normal commands. This breaks setup scripts, or baffles newbies who are told "follow these commands to get started". – Courses

Does this answer your question? How do I push a new local branch to a remote Git repository and track it too? – Religieuse

latest, git branch -u origin/<remote branch name you want to track> – Betake

Answer 1

Given a branch foo and a remote upstream:

As of Git 1.8.0:

git branch -u upstream/foo

Or, if local branch foo is not the current branch:

git branch -u upstream/foo foo

Or, if you like to type longer commands, these are equivalent to the above two:

git branch --set-upstream-to=upstream/foo

git branch --set-upstream-to=upstream/foo foo

As of Git 1.7.0 (before 1.8.0):

git branch --set-upstream foo upstream/foo

Notes:

• All of the above commands will cause local branch foo to track remote branch foo from remote upstream.
• The old (1.7.x) syntax is deprecated in favor of the new (1.8+) syntax. The new syntax is intended to be more intuitive and easier to remember.
• Defining an upstream branch will fail when run against newly-created remotes that have not already been fetched. In that case, run git fetch upstream beforehand.

---

See also: Why do I need to do `--set-upstream` all the time?

Petronius

Is "upstream" the name of the remote? i.e. what most would call "origin" by default? – Agglutinogen

@Andrew: Yes. git branch --set-upstream master origin/master would be equivalent to what is automatically done when you initially clone a repository. – Petronius

On a related note, adding this to your gitconfig is awesome: "[push] default=tracking" this will make it so that pushes will go the same place that pulls come from :) – Hedgcock

I get "fatal: Not a valid object name: 'origin/master'." – Satirical

Just in case someone didn't know: "git branch -a -v" shows what branches you have available, "git remote -v" shows what remotes you have. – Rodd

joachim: do you have a remote called "origin" with a branch "master" in it? git branch -r will show your remote branches. – Halation

joachim: I got the same error. In my case, I was changing servers for remote origin, so I renamed the remote. Then there was no more origin/master remote branch, so I needed to do this: git fetch origin git branch --set-upstream master origin/master git pull – Glasgo

git push -u origin foo via – Skateboard

@PaulHedderly (just to confirm), this command literally does nothing more than what your answer does? – Amory

@Satirical same error, I simply had to start by typing "git push origin master", because at first there was no master branch in the remote origin. – Sansculotte

For future reference: if you get "fatal: Ambigious object name: <your object name>", add remotes/ before it. So instead of git branch --set-upstream master origin/master, do git branch --set-upstream master remotes/origin/master. – Polson

@ErikHesselink I still get the ambiguous error, even with remotes/origin/master: warning: refname 'remotes/origin/master' is ambiguous. fatal: Ambiguous object name: 'remotes/origin/master'. – Grig

@J.PabloFernández: Try adding 'refs/' in front of the remote branch name, making it 'refs/remotes/origin/master'. – Polson

@ErikHesselink that din't help: git branch --set-upstream master refs/remotes/origin/master error: Not tracking: ambiguous information for ref refs/remotes/origin/master – Grig

@ErikHesselink nevermind... somehow I ended up with a messed up repo. – Grig

Also in recent git, if you have fetched new remote branch and don't have a local branch for it, then git checkout with the same branchname will auto created a tracking branch – Fencesitter

To display your origin and upstream, type git remote -v – Fowle

@Satirical See: Why does git not recognize “origin/master” as a valid object name? – Isochronize

I use Git 1.8.1.2 and it gives me: The --set-upstream flag is deprecated and will be removed. Consider using --track or --set-upstream-to – Skied

@ChrisFrancis Git never ceases to amaze me with its powerful and flexible features, accessed with a cryptic but surprisingly simple syntax. Sometimes when I come here I feel like I'm at Hogwarts learning new spells... – Deese

This actually works with git-svn as well, though you may need to do a little bit of work (like a regular git rebase) to get your local branch to no longer be diverged from the new svn branch. – Particolored

@AndrewVit I always set my remote repo (e.g. GitHub) to origin and the repo I forked from as upstream. Then I git fetch upstream and git branch -u origin/foo – Pottage

This doesn't work correctly in git 2.8.1. It tries to create a local branch called upstream/foo, even when upstream is a remote repo. – Eon

The 1st and 3rd solutions will only work when foo is the current branch according to the docs, even in 1.8. Since the question does not specify whether the "existing branch" is checked out, I feel that git branch -u upstream/foo and git branch --set-upstream-to=upstream/foo should be removed from this answer. – Ruvolo

git branch -u upstream/foo works for me , not try others. – Lovering

Also it can be used as: git branch -u origin/branch_name – Royroyal

Why don't git push to this branch by default? I have a sth branch, tracking a remote's master. git push and git push personal master don't work, but a lengthy git push rem HEAD:master works. – Barbital

I feel that this answer is missing some important steps. Because executing for example git branch --set-upstream-to=upstream/foo leads to error the requested upstream branch 'upstream/foo' does not exist – Mckinnie

@Mckinnie this is because in your case you don't have an upstream branch with name upstream/foo, you need to check the remote verbose with git remote -v to display the remote verbose name(s) list you have, let's assume it is origin. Then to link the origin/dev branch to my local foo branch I can type 'git branch -u origin/dev foo. In case the local branch and the remote one is foo` then git branch -u origin/foo. – Oblige

@Cotton's command worked for me where others did not – Mugger

Answer 2

You can do the following (assuming you are checked out on master and want to push to a remote branch master):

Set up the 'remote' if you don't have it already

git remote add origin ssh://...

Now configure master to know to track:

git config branch.master.remote origin
git config branch.master.merge refs/heads/master

And push:

git push origin master

Futhark

it is really required the remote and the branch in the push? I mean, you only need it if your checked out branch is not the one you want to push, right ? – Indenture

Yes - but from memory you may need to be explicit for the first push. Can easily be tested of course... :) – Futhark

+1 This is the answer for Windows users who are stuck with the msysgit "preview" that is pre 1.8. Thanks for that. – Pustulant

This is the only answer that worked for me. When I tried the accepted answer, to set the upstream remote for an existing branch, I got: error: the requested upstream branch 'upstream/master' does not exist. – Tinytinya

@SteveK that's most likely because your upstream is called origin and not upstream. – Frugal

Note that this translates to the following if you want to just manually update the .git/config file: [branch "master"] remote = origin merge = refs/heads/master – Fellowman

Answer 3

I do this as a side-effect of pushing with the -u option as in

$ git push -u origin branch-name

The equivalent long option is --set-upstream.

The git-branch command also understands --set-upstream, but its use can be confusing. Version 1.8.0 modifies the interface.

git branch --set-upstream is deprecated and may be removed in a relatively distant future. git branch [-u|--set-upstream-to] has been introduced with a saner order of arguments.

…

It was tempting to say git branch --set-upstream origin/master, but that tells Git to arrange the local branch "origin/master" to integrate with the currently checked-out branch, which is highly unlikely to be what the user meant. The option is deprecated; use the new --set-upstream-to (with a short-and-sweet -u) option instead.

Say you have a local foo branch checked out and want it to use a branch by the same name as its upstream. Make this happen with

$ git branch --set-upstream-to=origin/foo

Cher

Answer 4

For Git versions 1.8.0 and higher:

Actually for the accepted answer to work:

git remote add upstream <remote-url>
git fetch upstream
git branch -f --track qa upstream/qa
# OR Git version 1.8.0 and higher:
git branch --set-upstream-to=upstream/qa
# Gitversions lower than 1.8.0
git branch --set-upstream qa upstream/qa

Antipater

The local branch was already tracking a branch, so we can assume the remote repo was already added. – Indenture

Dopplerganger: See joachim's comment to the accepted answer. Anyway assumptions readily differ - it what makes things so interesting ;) – Antipater

Answer 5

You might find the git_remote_branch tool useful. It offers simple commands for creating, publishing, deleting, tracking & renaming remote branches. One nice feature is that you can ask a grb command to explain what git commands it would execute.

grb explain create my_branch github
# git_remote_branch version 0.3.0

# List of operations to do to create a new remote branch and track it locally:
git push github master:refs/heads/my_branch
git fetch github
git branch --track my_branch github/my_branch
git checkout my_branch

Punishment

grb is a ruby gem that can be accessed as explained on their github – Frighten

The OP is asking question about Git itself. So don't introduce a new tool would probably be better. – Arachnid

grb is an alias for git-rebase on my macOS installation. I didn't do this :) – Embranchment

Answer 6

1- update your local meta-data using : git fetch --all

2- show your remote and local branches using : git branch -a , see the following Screenshot

3- switch to target branch , that you want to linked with the remote: using

git checkout branchName

example :

4- Link your local branch to a remote branch using:

git branch --set-upstream-to nameOfRemoteBranch

N.B : nameOfRemoteBranch : to copy from the output of step 2 " git branch -r "

Example of use:

Barbee

Mostly easy and simple answer. – Restriction

Why is this not the top answer already? Can't believe it's 2023 and git commands are so unnecessarily complex. All I wanted to do was pull a remote branch, this answer was the simplest way to do that. – Timpani

Answer 7

I believe that in as early as Git 1.5.x you could make a local branch $BRANCH track a remote branch origin/$BRANCH, like this.

Given that $BRANCH and origin/$BRANCH exist, and you've not currently checked out $BRANCH (switch away if you have), do:

git branch -f --track $BRANCH origin/$BRANCH

This recreates $BRANCH as a tracking branch. The -f forces the creation despite $BRANCH existing already. --track is optional if the usual defaults are in place (that is, the git-config parameter branch.autosetupmerge is true).

Note, if origin/$BRANCH doesn't exist yet, you can create it by pushing your local $BRANCH into the remote repository with:

git push origin $BRANCH

Followed by the previous command to promote the local branch into a tracking branch.

Elysium

git push origin $BRANCH was what I was looking for. – Undergrowth

After trying all sorts of solutions, including setting up an upstream as described above nothing worked. All I wanted to do is pull 1 new commit into my local branch from a remote one and I didn't setup tracking initially. The command git branch -f --track $BRANCH origin/$BRANCH does the trick. – Talkathon

Answer 8

Make sure you run :

git config push.default tracking

to be able to push trouble free

Destruct

This could be convenient. We could note, however, that according to git-config(1) manual page, tracking is deprecated synonym of upstream. – Athirst

Beware! After branching a local branch from origin master with something like git checkout -b mybranch origin/master, and making changes on your local branch, the above will push to master on the remote when you run git push. For most people this would be unexpected. – Ridotto

Answer 9

Editing .git/config is probably the easiest and fastest way. That's what the Git commands for handling remote branches are doing, anyway.

If you don't want to muck with the file by hand (and it's not that hard to do), you can always use git config to do it...but again, that's just going to edit the .git/config file, anyway.

There are, of course, ways to automatically track a remote branch when using git checkout (by passing the --track flag, for example), but these commands work with new branches, not existing ones.

Dimitrovo

Answer 10

In very short

git branch --set-upstream yourLocalBranchName origin/develop

This will make your yourLocalBranchName track the remote branch called develop.

Refrigerator

@Quincy Check greg's answer - use git push -u origin branch (or --set-upstream-to) instead – Ozellaozen

@MadNik, what is the difference between --set-upstream and --track? I don't quite understand why I should use one over the other. – Pluvial

Answer 11

For 1.6.x, it can be done using the git_remote_branch tool:

grb track foo upstream

That will cause Git to make foo track upstream/foo.

Bondy

Answer 12

I use the following command (Suppose your local branch name is "branch-name-local" and remote branch name is "branch-name-remote"):

$ git branch --set-upstream-to=origin/branch-name-remote branch-name-local

If both local and remote branches have the same name, then just do the following:

$ git branch --set-upstream-to=origin/branch-name branch-name

Sos

You reversed "branch-name" and "origin/branch-name" on the command line. The upstream comes before the local. – Lorrimor

@maharvey67 you are right, thanks. Edited the answer. – Sos

This was gold, thank you, also because none of the options within the accepted answer are ok when you have slashes in the branch name – Stepfather

Answer 13

For creating new branch, we could use following command

 git checkout --track -b example origin/example 

For the already created branch to create link between remote then from that branch use below command

 git branch -u origin/remote-branch-name

Melina

Answer 14

Use '--track' Option

• After a git pull :

  git checkout --track <remote-branch-name>

• Or:

  git fetch && git checkout <branch-name>

Gandy

Answer 15

Here, using github and git version 2.1.4, just do:

$ git clone [email protected]:user/repo.git

And remotes come by itelsef, even if not linked locally:

$ git remote show origin

* remote origin
  Fetch URL: [email protected]:user/repo.git
  Push  URL: [email protected]:user/repo.git
  HEAD branch: master
  Remote branches:
    develop tracked         <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
    master  tracked
  Local branch configured for 'git pull':
    master merges with remote master
  Local ref configured for 'git push':
    master pushes to master (up to date)

But of course, still no local branch:

$ git branch
* master                  <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

See? Now if you just checkout develp, it will do the magic automatically:

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

So easy!

---

Summary. Just run this 2 commands:

$ git clone [email protected]:user/repo.git
$ git checkout develop

Chickadee

An excellent example of my identical use case. Despite no sign of a local 'develop' branch, when I checked out the 'develop' branch that branch appears and is magically set up to track the remote branch 'develop' from origin. I appreciate the step by step example and explanation! – Circumvallate

Answer 16

In case you got "error: the requested upstream branch 'origin/foo' does not exist" after running:

git branch -u origin/foo

---

1. Make sure origin does have a foo branch.

2. Make sure the remote.origin.fetch variable is set to +refs/heads/*:refs/remotes/origin/*:

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

3. Run git fetch -v. You should see git updating from origin/foo:

$ git fetch -v
From github.com:davidhcefx/test
 * [new branch]      foo             -> origin/foo
 = [up to date]      master          -> origin/master

4. Upon success, git branch -avv will show square brackets, indicating tracked remote branches:

$ git branch -u origin/foo
branch 'foo' set up to track 'origin/foo'.
$ git branch -avv
* foo                            92c5ada [origin/foo] Initial commit
  master                         92c5ada [origin/master] Initial commit

Cyclopean

Answer 17

This isn't a direct answer to this question, but I wanted to leave a note here for anyone who may be having the same issue as me when trying to configure an upstream branch.

Be wary of push.default.

With older git versions, the default was matching, which would cause very undesirable behaviour if you have, for example:

Local branch "master" tracking to origin/master

Remote branch "upstream" tracking to upstream/master

If you tried to "git push" when on the "upstream" branch, with push.default matching git would automatically try to merge the local branch "master" into "upstream/master", causing a whole lot of chaos.

This gives more sane behaviour:

git config --global push.default upstream

Severn

You did not leave this in vain. Thanks. – Termor

Answer 18

For git version 2.25.1, use the command:

git push --set-upstream origin <local_branch_name>

Hygienic

This could be inconvenient if you don't plan to push your changes yet! – Squeegee

Answer 19

In a somewhat related way I was trying to add a remote tracking branch to an existing branch, but did not have access to that remote repository on the system where I wanted to add that remote tracking branch on (because I frequently export a copy of this repo via sneakernet to another system that has the access to push to that remote). I found that there was no way to force adding a remote branch on the local that hadn't been fetched yet (so local did not know that the branch existed on the remote and I would get the error: the requested upstream branch 'origin/remotebranchname' does not exist).

In the end I managed to add the new, previously unknown remote branch (without fetching) by adding a new head file at .git/refs/remotes/origin/remotebranchname and then copying the ref (eyeballing was quickest, lame as it was ;-) from the system with access to the origin repo to the workstation (with the local repo where I was adding the remote branch on).

Once that was done, I could then use git branch --set-upstream-to=origin/remotebranchname

Acaudal

Answer 20

or simply by :

switch to the branch if you are not in it already:

[za]$ git checkout branch_name

run

[za]$ git branch --set-upstream origin branch_name
Branch origin set up to track local branch brnach_name by rebasing.

and you ready to :

 [za]$ git push origin branch_name

You can alawys take a look at the config file to see what is tracking what by running:

 [za]$ git config -e

It's also nice to know this, it shows which branches are tracked and which ones are not. :

  [za]$ git remote show origin 

Resurrect

Answer 21

For anyone who, like me, just wants to sync up your local branch name with the remote branch name, here's a handy command:

git branch -u origin/$(git rev-parse --abbrev-ref HEAD)

Parchment

Answer 22

To avoid remembering what you need to do each time you get the message:

Please specify which branch you want to merge with. See git-pull(1)
for details.
.....

You can use the following script which sets origin as upstream for the current branch you are in.

In my case I almost never set something else than origin as the default upstream. Also I almost always keep the same branch name for local and remote branch. So the following fits me:

#!/bin/bash
# scriptname: git-branch-set-originupstream
current_branch="$(git branch | grep -oP '(?<=^\* )(.*)$')"
upstream="origin/$current_branch"
git branch -u "$upstream"

Nigel

In git 2.37+, you probably want git config --global branch.autoSetupMerge simple and git config --global push.autoSetupRemote true. At checkout you will get tracking only if the local branch name matches the remote, and at git push time a new local branch will create the new remote branch, with tracking, automatically. – Ridotto

Answer 23

This would work too

git branch --set-upstream-to=/< remote>/< branch> < localbranch>

Didynamous