How to get default Git branch?

I found a way to detect the default-branch if it is not master.

git remote show [your_remote] | sed -n '/HEAD branch/s/.*: //p'

I tested it with multiple repo from gitlab, and it worked fine. (for the most situations [your_remote] will be origin, run git remote to check the name of your remote)

You can use git rev-parse.

git rev-parse --abbrev-ref origin/HEAD will print origin/<default-branch-name>.

The git symbolic-ref answers are doing the same thing but need a longer argument.

If the origin repository changes its default branch name, then git remote set-head origin -a will retrieve the new default branch name.

There doesn't seem to be an answer that doesn't require cloning so far

This requires git 2.8.0 or newer

$ git ls-remote --symref [email protected]:pre-commit/pre-commit.github.io HEAD
ref: refs/heads/real_master HEAD
e100a6a3c72b4e54f0d176f791dfd2dbd7eb5fa7    HEAD

This question is a bit old but in case anyone comes across this more recently...

git remote show <remote_name> | awk '/HEAD branch/ {print $NF}'

That will also only display the branch name, not including any of the whitespace or other nonsense.

I like to save this using a couple git aliases (I have a bunch of useful aliases like this):

upstream-name = !git remote | egrep -o '(upstream|origin)' | tail -1
head-branch = !git remote show $(git upstream-name) | awk '/HEAD branch/ {print $NF}'

I use "upstream" and "origin" as my remotes almost 100% of the time ("upstream" when I go with a Fork & Pull workflow... which is often). Your use case may not need the upstream-name alias, I just find it useful.

There is a --short option to git symbolic-ref. So my preferred command:

$ basename $(git symbolic-ref --short refs/remotes/origin/HEAD) 
master

Requirements

You need refs/remotes/origin/HEAD and it is only set when cloning. Otherwise you need to set it yourself with

git remote set-head origin -a

More info

Command

The following command will list the HEAD branch, no matter how you have named your remotes:

git branch --remotes --list '*/HEAD'

From that you can extract the default branch like this:

git branch -rl '*/HEAD' | rev | cut -d/ -f1 | rev

(using short variants of the git branch arguments).

If your shell does not have the rev command, you can use awk instead:

git branch -rl '*/HEAD' | awk -F/ '{print $NF}'

If your shell is bash or bash-compatible, you can use variable string operations (thanks @qneill):

(out=$(git branch -rl '*/HEAD'); echo ${out##*/})

(The outer parentheses prevent a variable -- out in this example -- from being created or overwritten in the current shell session.)

This is possible to get with the gh cli tool (tested v2.0.0)

gh repo view --json defaultBranchRef --jq .defaultBranchRef.name

As noted by other answerers, the concept of a default branch is a GitHub thing doesn't really make sense (in the lofty sense) of Git (there's a reasonably good (if under-appreciated) comment here gets into it a bit: https://stackoverflow.com/a/65710958/2521092) but in practice, we all know what that means.

Since the original asking of this question, Git 2.28 added init.defaultBranch, allowing a different initial branch than master, and a lot of projects are now using main. That's good. Most of the answers here rely on checking a remote, but that relies on there actually being a remote, and that there exists a reliable and consistent naming scheme to those remotes. Those are probably (increasingly?) reasonable assumptions, but it's not a guarantee, and I don't find that any of the major answers here fail nicely.

Moreover, my main use case is using the name of the default branch for various git aliases (e.g. lm = log main..HEAD). I'd like to use the same aliases without thinking about it too much, regardless of an external repo using master or a local using main with no remote. Git and its config can't really "store" information, so there's no way to set ahead of time what the current repository's main branch is. As such, any alias that wants to, say, show commits between the main branch and HEAD can't assume git log master..HEAD or git log main..HEAD will work.

Thus, I define a default-branch alias in Git that figures out the default branch and then supply that to other aliases. This is a pain since a simple lm = log main..HEAD has to instead become lm = "!git log $(git default-branch)..HEAD" but here we are:

default-branch = "!git branch --sort=-refname | grep -o -m1 '\\b\\(main\\|master\\|dev\\)\\b'"

This simply gets the branch names then finds the first one in a defined list. If there's a main, use that; if not and there's a master, use that. I also have dev in there as a tertiary option some folks use.

This is sort of similar to what @henrik-n does in https://stackoverflow.com/a/66622363/2521092, but I do it in Git itself rather than the shell, and I think it has some more optionality.

Is there a git command available to determine default branch for remote repository?

This list the default local repository branch:

git rev-parse --abbrev-ref $(git remote)/HEAD

The GitHub API can show the default branch with using its CLI gh:

gh api /repos/{owner}/{repo} --jq '.default_branch'

All other answers made too many assumptions, this is the only way that worked for me. This works regardless of what branch you're currently on, doesn't assume the origin/HEAD ref exists locally, and will always reflect the current default branch even if it's been changed.

The only drawback is that it alters the local origin/HEAD ref, but that shouldn't generally be a problem.

Allow git to set your origin/HEAD, determining what branch to use automatically:

$ git remote set-head origin --auto
origin/HEAD set to main

Then, get a string containing the name of the default branch:

$ git rev-parse --abbrev-ref origin/HEAD
origin/main

Alternatively, for a one-line solution:

$ git remote set-head origin --auto >/dev/null 2>&1 && git rev-parse --abbrev-ref origin/HEAD
origin/main

I just wanted a shell script to know whether the branch is "master" or "main".

For that purpose, this seems good enough:

[ -f "$(git rev-parse --show-toplevel)/.git/refs/heads/master" ] && echo master || echo main

If you know it will always be called from the root directory of the repo, it can be simplified to

[ -f .git/refs/heads/master ] && echo master || echo main

I'm using this in my Git aliases like so: https://github.com/henrik/dotfiles/commit/6815bd95770afab2936fb6202b1ee5e82cb9662b

If like this question you are trying to get a GitHub default branch--not some other git server:

You can get the default branch using the /repos GitHub API. It's the default_branch field of the response:

$ curl -s https://api.github.com/repos/darthwalsh/bootstrappingCIL | \
      jq --raw-output .default_branch
master

This works for me with Git 2.1.10, using a repository cloned from GitHub:

git branch -r --points-at refs/remotes/origin/HEAD

A major problem with this approach is that it lists every remote branch pointing to HEAD; however, the output includes a hint:

  origin/HEAD -> origin/master
  origin/master
  origin/test123

So you can post-process the output with grep or similar to find the one with the arrow:

git branch -r --points-at refs/remotes/origin/HEAD | grep '\->' | cut -d' ' -f5 | cut -d/ -f2

From git 2.28.0 and above:

$ git config --get init.defaultBranch || echo master

Adding some context about remote names to the excellent answers of danielkza or Jerrey Yasskin.

So the example show it's possible to get the default branch of the remote named origin.

$ git rev-parse --abbrev-ref origin/HEAD
origin/master

But if the remote are not named origin this could fail

$ git remote show
bric3
upstream

$ git rev-parse --abbrev-ref origin/HEAD
origin/HEAD
fatal: ambiguous argument 'origin/HEAD': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions, like this:
'git <command> [<revision>...] -- [<file>...]'

Also not all remote have a default branch

$ git rev-parse --abbrev-ref bric3/HEAD
bric3/HEAD
fatal: ambiguous argument 'bric3/HEAD': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions, like this:
'git <command> [<revision>...] -- [<file>...]'

$ ls .git/refs/remotes/bric3/HEAD
".git/refs/remotes/bric3/HEAD": No such file or directory (os error 2)

$ git rev-parse --abbrev-ref upstream/HEAD
upstream/master

$ ls .git/refs/remotes/upstream/HEAD
.git/refs/remotes/upstream/HEAD

I'll add yet another answer, based on the other answers. I didn't like any of the other answers because querying a remote is slow, but I also didn't want a "local-only" solution.

I use this (long) alias:

head-branch = "!f() { gitHeadsDir=\"$(git rev-parse --show-toplevel)/.git/refs/heads\"; if [ -f \"$gitHeadsDir/main\" ]; then echo 'main'; elif [ -f \"$gitHeadsDir/master\" ]; then echo 'master'; else git remote show origin | grep 'HEAD branch' | cut -d' ' -f5; fi; }; f"

The above basically does this:

• if a local branch named main exists, use that
• if a local branch named master exists, use that
• otherwise, fall back to checking the remote (which is much slower)

This works for 99 % of use cases (and all of my use cases), including:

• a "regular" cloned repository
• a brand new repository, which might not even have a remote (yet).

You can still easily "break" this by creating a local branch named main or master (or both), even if that's not actually the default branch. This will also fail if you don't have a remote, and your default branch name is neither main or master. But in those cases you're most likely trying to break it. ;-)

I'm checking for main first, since if you have both main and master, you're likely in the process of switching from master to main.

Most of the answers are based on git remote show, which is very slow for me (almost a full second on a repo with only a few branches). In the comments, using git symbolic-ref was mentioned. This is much faster (feels instant).

If that matters to you, here is a crappy benchmark that runs 50 iterations each:

• git remote show origin | sed -n '/HEAD branch/s/.*: //p'
• git symbolic-ref refs/remotes/origin/HEAD | sed 's/.*\///'

echo -ne "\nremote show:"
time for i in {1..50}; do git remote show origin | sed -n '/HEAD branch/s/.*: //p' >/dev/null; done
echo -ne "\nsymbolic-ref:"
time for i in {1..50}; do git symbolic-ref refs/remotes/origin/HEAD | sed 's/.*\///' >/dev/null; done

Output running on a crappy Chromebook VM:

remote show:
real    0m32.495s
user    0m1.566s
sys 0m0.811s

symbolic-ref:
real    0m0.207s
user    0m0.115s
sys 0m0.218s

Update: I think a clearer/faster version is: cat .git/refs/remotes/origin/HEAD | sed 's/.*\///' (but this only works from the root of the repo, whereas the other versions work from any directory inside the repo)

Seems like a bit of a workaround solution but this seems to work:

$ cat .git/refs/remotes/origin/HEAD 
ref: refs/remotes/origin/master

In Powershell to get the main branch remotely (without cloning anything locally) I just use this line

$remoteMasterBranchName = $(Split-Path ([Regex]::Matches((git ls-remote --symref $repository),"ref:\s+(\S+)\s+HEAD").Groups[1].Value) -Leaf)

If you need to convert it to another scripting language it essentially does 3 things:

1. Executes the command git ls-remote --symref <repository clone url>
2. Extracts the first match of the output with the regex "ref:\s+(\S+)\s+HEAD", e.g. lines like the one below (/s matches any whitespace character, /S matches any non-whitespace character):
   
   ref: refs/heads/master HEAD
   
   and brings out the central part refs/heads/master into the first regex group [(\S+) in regexp, Groups[1].Value in powershell]:
3. Takes out the last part of the path refs/heads/master using Split-Path cmdlet, e.g. master which is the default branch we are looking for.

Here's the straight-forward, easy to do (and correct) method to both set and check your default branch in Git.

To set the default branch to whatever you want when you do a git init enter the following:

~$ git config set --global init.defaultBranch master

To check what your default branch is going to be whenever you initialize a git repo, enter the following:

~$ git config list

[email protected]
user.name=joeuser
init.defaultbranch=master

> git var GIT_DEFAULT_BRANCH
master

From the docs for git var:

GIT_DEFAULT_BRANCH: The name of the first branch created in newly initialized repositories.

This variable was added in git 2.35.