How can I delete all Git branches which have been merged?

I have many Git branches. How do I delete branches which have already been merged? Is there an easy way to delete them all instead of deleting them one by one?

git branch -D

master

git branch -a

git fetch --prune

git delete-merged --doit origin

git delete-merged --doit --local

34 Answers
34

UPDATE:

You can add other branches to exclude like master and dev if your workflow has those as a possible ancestor. Usually I branch off of a "sprint-start" tag and master, dev and qa are not ancestors.

To delete all local branches that are already merged into the currently checked out branch:

git branch --merged | egrep -v "(^*|master|dev)" | xargs git branch -d


You can see that master and dev are excluded in case they are an ancestor.

You can delete a merged local branch with:

git branch -d branchname


If it's not merged, use:

git branch -D branchname


To delete it from the remote in old versions of Git use:

git push origin :branchname


In more recent versions of Git use:

git push --delete origin branchname


Once you delete the branch from the remote, you can prune to get rid of remote tracking branches with:

git remote prune origin


or prune individual remote tracking branches, as the other answer suggests, with:

git branch -dr branchname


Hope this helps.

git branch --merged | %{$_.trim()} | ?{$_ -notmatch 'develop' -and $_ -notmatch 'master'} | %{git branch -d $_}

fatal: branch name required

-r

xargs

git branch -d

To delete all branches on remote that are already merged:

git branch -r --merged | grep -v master | sed 's/origin//:/' | xargs -n 1 git push origin


In more recent versions of Git

git branch -r --merged | grep -v master | sed 's/origin///' | xargs -n 1 git push --delete origin


dev

| grep origin

grep -v master

git branch -r --merged | grep -v master | grep origin | sed 's/origin//:/' | xargs -n 1 echo

develop

git branch -r --merged | grep -v master | grep -v develop | sed 's/origin///' | xargs -n 1 git push --delete origin

-r

myFeatureBranch

origin/myFeatureBranch

git checkout master

Just extending Adam's answer a little bit:

Add this to your Git configuration by running git config -e --global

git config -e --global

[alias]
cleanup = "!git branch --merged | grep -v '\*\|master\|develop' | xargs -n 1 git branch -d"


And then you can delete all the local merged branches doing a simple git cleanup.

git cleanup

git branch --merged master

develop

dev

fatal: malformed object name

-r

xargs

branch name required

cleanup = "!git branch --merged | grep -v -P '^\*|master|develop' | xargs -n1 -r git branch -d"

This also works to delete all merged branches except master.

git branch --merged | grep -v '^* master$' | grep -v '^ master$' | xargs git branch -d


master

grep -v ^master$

| grep -v '^*'

grep -v '^ master$'

master

git branch

You'll want to exclude the master & develop branches from those commands.

master

develop

Local git clear:

git branch --merged | grep -v '*|master|develop' | xargs -n 1 git branch -d


Remote git clear:

git branch -r --merged | grep -v '*|master|develop' | sed 's/origin///' | xargs -n 1 git push --delete origin


Sync local registry of remote branches:

git fetch -p


git config --global --add fetch.prune true

For those of you that are on Windows and prefer PowerShell scripts, here is one that deletes local merged branches:

function Remove-MergedBranches
{
git branch --merged |
ForEach-Object { $_.Trim() } |
Where-Object {$_ -NotMatch "^*"} |
Where-Object {-not ( $_ -Like "*master" )} |
ForEach-Object { git branch -d $_ }
}


git branch --merged | ?{-not ($_ -like "*master")} | %{git branch -d $_.trim()}

for /f "usebackq" %B in (``git branch --merged^|findstr /v /c:"* " /c:"master"``) do @git branch -d %B

Git Sweep does a great job of this.

You can add the commit to the --merged option.
This way you can make sure only to remove branches which are merged into i.e. the origin/master

Following command will remove merged branches from your origin.

git branch -r --merged origin/master | grep -v "^.*master" | sed s:origin/:: |xargs -n 1 git push origin --delete


You can test which branches will be removed replacing the git push origin --delete with echo

git branch -r --merged origin/master | grep -v "^.*master" | sed s:origin/:: |xargs -n 1 echo


I use the following Ruby script to delete my already merged local and remote branches. If I'm doing it for a repository with multiple remotes and only want to delete from one, I just add a select statement to the remotes list to only get the remotes I want.

#!/usr/bin/env ruby

current_branch = `git symbolic-ref --short HEAD`.chomp
if current_branch != "master"
if $?.exitstatus == 0
puts "WARNING: You are on branch #{current_branch}, NOT master."
else
puts "WARNING: You are not on a branch"
end
puts
end

puts "Fetching merged branches..."
remote_branches= `git branch -r --merged`.
split("n").
map(&:strip).
reject {|b| b =~ //(#{current_branch}|master)/}

local_branches= `git branch --merged`.
gsub(/^* /, '').
split("n").
map(&:strip).
reject {|b| b =~ /(#{current_branch}|master)/}

if remote_branches.empty? && local_branches.empty?
puts "No existing branches have been merged into #{current_branch}."
else
puts "This will remove the following branches:"
puts remote_branches.join("n")
puts local_branches.join("n")
puts "Proceed?"
if gets =~ /^y/i
remote_branches.each do |b|
remote, branch = b.split(///)
`git push #{remote} :#{branch}`
end

# Remove local branches
`git branch -d #{local_branches.join(' ')}`
else
puts "No branches removed."
end
end


/

remote_branches

b.split(///)

Using Git version 2.5.0:

git branch -d `git branch --merged`


master

master

git branch -d $(git branch --merged | grep -v master)

kuboon's answer missed deleting branches which have the word master in the branch name.
The following improves on his answer:

git branch -r --merged | grep -v "origin/master$" | sed 's/s*origin///' | xargs -n 1 git push --delete origin


Of course, it does not delete the "master" branch itself :)

git branch --merged | %{git branch -d $_.Trim()}


See GitHub for Windows

* master

There is no command in Git that will do this for you automatically. But you can write a script that uses Git commands to give you what you need. This could be done in many ways depending on what branching model you are using.

If you need to know if a branch has been merged into master the following command will yield no output if myTopicBranch has been merged (i.e. you can delete it)

$ git rev-list master | grep $(git rev-parse myTopicBranch)


You could use the Git branch command and parse out all branches in Bash and do a for loop over all branches. In this loop you check with above command if you can delete the branch or not.

for

git branch --merged | grep -Ev '^(. master|*)' | xargs -n 1 git branch -d will delete all local branches except the current checked out branch and/or master.

git branch --merged | grep -Ev '^(. master|*)' | xargs -n 1 git branch -d

master

Here's a helpful article for those looking to understand these commands: Git Clean: Delete Already Merged Branches, by Steven Harman.

You can use git-del-br tool.

git-del-br

git-del-br -a


You can install it via pip using

pip

pip install git-del-br


P.S: I am the author of the tool. Any suggestions/feedback are welcome.

Alias version of Adam's updated answer:

[alias]
branch-cleanup = "!git branch --merged | egrep -v "(^\*|master|dev)" | xargs git branch -d #"


Also, see this answer for handy tips on escaping complex aliases.

If you'd like to delete all local branches that are already merged in to the branch that you are currently on, then I've come up with a safe command to do so, based on earlier answers:

git branch --merged | grep -v * | grep -v '^s*master$' | xargs -t -n 1 git branch -d


This command will not affect your current branch or your master branch. It will also tell you what it's doing before it does it, using the -t flag of xargs.

Try the following command:

git branch -d $(git branch --merged | grep -vw $(git rev-parse --abbrev-ref HEAD))

git branch -d $(git branch --merged | grep -vw $(git rev-parse --abbrev-ref HEAD))

By using git rev-parse will get the current branch name in order to exclude it. If you got the error, that means there are no local branches to remove.

git rev-parse

To do the same with remote branches (change origin with your remote name), try:

origin

git push origin -vd $(git branch -r --merged | grep -vw $(git rev-parse --abbrev-ref HEAD) | cut -d/ -f2)

git push origin -vd $(git branch -r --merged | grep -vw $(git rev-parse --abbrev-ref HEAD) | cut -d/ -f2)

^{In case you've multiple remotes, add grep origin | before cut to filter only the origin.}

grep origin |

cut

origin

If above command fails, try to delete the merged remote-tracking branches first:

git branch -rd $(git branch -r --merged | grep -vw $(git rev-parse --abbrev-ref HEAD))

git branch -rd $(git branch -r --merged | grep -vw $(git rev-parse --abbrev-ref HEAD))

Then git fetch the remote again and use the previous git push -vdcommand again.

git fetch

git push -vd

If you're using it often, consider adding as aliases into your ~/.gitconfig file.

~/.gitconfig

In case you've removed some branches by mistake, use git reflog to find the lost commits.

git reflog

Based on some of these answers I made my own Bash script to do it too!

It uses git branch --merged and git branch -d to delete the branches that have been merged and prompts you for each of the branches before deleting.

git branch --merged

git branch -d

merged_branches(){
local current_branch=$(git rev-parse --abbrev-ref HEAD)
for branch in $(git branch --merged | cut -c3-)
do
echo "Branch $branch is already merged into $current_branch."
echo "Would you like to delete it? [Y]es/[N]o "
read REPLY
if [[ $REPLY =~ ^[Yy] ]]; then
git branch -d $branch
fi
done
}


I use a git-flow esque naming scheme, so this works very safely for me:

git branch --merged | grep -e "^s+(fix|feature)/" | xargs git branch -d


It basically looks for merged commits that start with either string fix/ or feature/.

fix/

feature/

Below query works for me

for branch in `git branch -r --merged | grep -v '*|master|develop'|awk 'NR > 0 {print$1}'|awk '{gsub(/origin//, "")}1'`;do git push origin --delete $branch; done


and this will filter any given branch in the grep pipe.

Works well over http clone, but not so well for the ssh connection.

Write a script in which Git checks out all the branches that have been merged to master.

Then do git checkout master.

git checkout master

Finally, delete the merged branches.

for k in $(git branch -ra --merged | egrep -v "(^*|master)"); do
branchnew=$(echo $k | sed -e "s/origin///" | sed -e "s/remotes///")
echo branch-name: $branchnew
git checkout $branchnew
done

git checkout master

for k in $(git branch -ra --merged | egrep -v "(^*|master)"); do
branchnew=$(echo $k | sed -e "s/origin///" | sed -e "s/remotes///")
echo branch-name: $branchnew
git push origin --delete $branchnew
done


The accepted solution is pretty good, but has the one issue that it also deletes local branches that were not yet merged into a remote.

If you look at the output of you will see something like

$ git branch --merged master -v
api_doc 3a05427 [gone] Start of describing the Java API
bla 52e080a Update wording.
branch-1.0 32f1a72 [maven-release-plugin] prepare release 1.0.1
initial_proposal 6e59fb0 [gone] Original proposal, converted to AsciiDoc.
issue_248 be2ba3c Skip unit-for-type checking. This needs more work. (#254)
master be2ba3c Skip unit-for-type checking. This needs more work. (#254)


Branches bla and issue_248 are local branches that would be deleted silently.

bla

issue_248

But you can also see the word [gone], which indicate branches that had been pushed to a remote (which is now gone) and thus denote branches can be deleted.

[gone]

The original answer can thus be changed to (split into multiline for shorter line length)

git branch --merged master -v |
grep "\[gone\]" |
sed -e 's/^..//' -e 's/S* .*//' |
xargs git branch -d


to protect the not yet merged branches.
Also the grepping for master to protect it, is not needed, as this has a remote at origin and does not show up as gone.

To avoid accidentally running the command from any other branch than master I use the following bash script. Otherwise, running git branch --merged | grep -v "*" | xargs -n 1 git branch -d from a branch that has been merged of off master could delete the master branch.

git branch --merged | grep -v "*" | xargs -n 1 git branch -d

#!/bin/bash

branch_name="$(git symbolic-ref HEAD 2>/dev/null)" ||
branch_name="(unnamed branch)" # detached HEAD
branch_name=${branch_name##refs/heads/}

if [[ $branch_name == 'master' ]]; then
read -r -p "Are you sure? [y/N] " response
if [[ $response =~ ^([yY][eE][sS]|[yY])$ ]]; then
git branch --merged | grep -v "*" | xargs -n 1 git branch -d
fi
else
echo "Refusing to delete branches that are not merged into '$branch_name'. Checkout master first."
fi


To delete local branches that have been merged to master branch I'm using the following alias (git config -e --global):

git config -e --global

cleanup = "!git branch --merged master | grep -v '^*\|master' | xargs -n 1 git branch -D"


I'm using git branch -D to avoid error: The branch 'some-branch' is not fully merged. messages while my current checkout is different from master branch.

git branch -D

error: The branch 'some-branch' is not fully merged.

Windoze-friendly Python script (because git-sweep choked on Wesnoth repository):

git-sweep

#!/usr/bin/env python
# Remove merged git branches. Cross-platform way to execute:
#
# git branch --merged | grep -v master | xargs git branch -d
#
# Requires gitapi - https://bitbucket.org/haard/gitapi
# License: Public Domain

import gitapi

repo = gitapi.Repo('.')
output = repo.git_command('branch', '--merged').strip()
for branch in output.split('n'):
branch = branch.strip()
if branch.strip(' *') != 'master':
print(repo.git_command('branch', '-d', branch).strip())


https://gist.github.com/techtonik/b3f0d4b9a56dbacb3afc

If you are using branching model like HubFlow or GitFlow you can use this command to remove the merged feature branches:

git branch --merged | grep feature.* | grep -v "*" | xargs -n 1 git branch -d

git branch --merged | grep feature.* | grep -v "*" | xargs -n 1 git branch -d

If you wish to delete local branches that have been merged as well as delete their remotes here's the one-liner I prefer:

git branch --merged | xargs -I_br -- sh -c 'git branch -d _br; git push origin --delete _br'


for b in $(git branch -a | grep -v "(master|remotes)"); do
git branch -D $b; done && git fetch -p


Let's say I have a remote named upstream and an origin (GitHub style, my fork is origin, upstream is upstream).

I don't want to delete ANY masters, HEAD, or anything from the upstream. I also don't want to delete the develop branch as that is our common branch we create PRs from.

List all remote branches, filtered by ones that were merged:

git branch -r


Remove lines from that list that contain words I know are in branch names I don't want to remove:

sed '/develop|master|HEAD|upstream/d'


Remove the remote name from the reference name (origin/somebranch becomes somebranch):

sed 's/.*///'


Use xargs to call a one-liner:

xargs git push --delete origin


Pipe it all together you get:

git branch -r --merged | sed '/develop|master|HEAD|upstream/d' | sed 's/.*///' | xargs git push --delete origin


This will leave me with only some branches that I have worked on, but have not merged. You can then remove them one by one as there shouldn't be too many.

Find branches you no longer want:

git branch -ar


Say you find branch1, branch2, and branch3 you want to delete:

git push --delete origin branch1 branch2 branch3


By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service, privacy policy and cookie policy, and that your continued use of the website is subject to these policies.