Delete multiple remote branches in git

I have a team member who inadvertently pushed over 150 of his local branches to our central repo. Thankfully, they all have the same prefix. Using that prefix, is there a git command or cool little shell script I can use that will delete all of those at once?

Use the following command to remove all branches with PREFIX prefix on remote server.

git branch -r | awk -F/ '/\/PREFIX/{print $2}' | xargs -I {} git push origin :{}

You may want to do a dry-run first to see if it is the branches that you want to remove:

git branch -r | awk -F/ '/\/PREFIX/{print $2}'

If you like a simpler approach, for instance delete 3 or 4 branches:

git push origin --delete <branch1> <branch2> <branch3>

Important: Only works on Git v1.7.0 and above.

Thanks to Neevek for great and elegant solution!

But i have some troubles with slashes in branch names (i'm using Git Flow), because of awk field separator / (-F option)

So my solution is based on Neevek's, but correctly parses branch names with /. In this case i presume that your remote called origin. Command for deleting remote branches with names staring with PATTERN:

git branch -r | awk -Forigin/ '/\/PATTERN/ {print $2}' | xargs -I {} git push origin :{}

And don't forget to check what you are going to delete:

git branch -r | awk -Forigin/ '/\/PATTERN/ {print $2}'

USEFUL TIP: If your branch names (without origin/ prefix) stored in a text file (one branch name per line), just run:

cat your_file.txt | xargs -I {} git push origin :{}

This may be a duplicate answer but below tested and worked for me perfectly.

1. Delete local branch forcefully

> git branch -D branch-name

2. Delete Remote branch

> git push origin --delete branch-name

3. Delete more than 1 local branch

> git branch -D branch-name1 branch-name2

4. Delete more than 1 remote branch

> git push origin --delete branch-name1 branch-name2

5. Delete local branch with prefix. For example, feature/*

> git branch -D $(git branch --list 'feature/*')

git branch -D backticks $(git branch --list 'feature/*' backticks)

6. List remote branch with prefix.

> git branch -r | grep -Eo 'feature/.*'

7. Delete remote branch with prefix

> git branch -r | grep -Eo 'feature/.*' | xargs -I {} git push origin > :{}

The same with grep: git branch -r | grep -Eo 'PREFIX/.*' | xargs -i git push origin :{}.

branch -r shows origin/prefix/branchname. So it will take prefix/branchname.

Neevek's solution is elegant, but it can be better: the solution as proposed calls 'git push' once per branch, which means an additional network round-trip per branch to be deleted. Since you're using awk anyway, why not use it to prefix the ':' and then xargs can call 'git push' exactly once and delete all the branches at once:

Dry-run to list the branches that would be deleted:

git branch -r | awk -F/ '/\/PREFIX/{print ":" $2}'

Final solution to actually push the deletes:

git branch -r | awk -F/ '/\/PREFIX/{print ":" $2}' | xargs git push origin

resource https://coderwall.com/p/eis0ba

    1 - List all your remote branches:
    
    $ git branch -r

    2 - Filter the branches by some regular expression. In this case I'm interested in deleting any branch with the 'feature-' prefix:
    
    $ git branch -r | awk -F/ '/\/feature-/{print $2}'
    3 - Pipe the last command to git push to delete them:
    # **Edit** - Removed extra colon, which is not needed
    $ git branch -r | awk -F/ '/\/feature-/{print $2}' | xargs -I {} git push origin {}
    4 - Grab a beer.
    
    5 - Remove any local reference to those branches:
    
    $ git remote prune origin

Thanks to Steve and Neevek, I found a solution that worked pretty well for me I figured worth sharing:

Steve's solution worked for me with one minor adjustment. My remotes were named origin/feature/some-feature-name so I trimmed your awk:

git branch -r | awk -Forigin/ '/\/feature/ {print $2 $3}' | xargs -I {} git push origin :{}

It's now doing a nice little delete flow:

To github.com:project/project-name.git
- [deleted]         feature/search-min-chars
To github.com:project/project-name.git
- [deleted]         feature/search-placeholder
To github.com:project/project-name.git
- [deleted]         feature/server-error-message
To github.com:project/project-name.git
- [deleted]         feature/six-point-asterisk

Was wondering if anyone had any ideas for a more elegant solution, though, that might output something like this (my CLI scripting is pretty poor, so it'd take me awhile to figure this out):

git push origin :feature/search-min-chars :feature/search-placeholder :feature/server-error-message :feature/six-point-asterisk

This would result in a nice single output with one network request:

To github.com:project/project-name.git
- [deleted]         feature/search-min-chars
- [deleted]         feature/search-placeholder
- [deleted]         feature/server-error-message
- [deleted]         feature/six-point-asterisk

Thanks to Neevek. This worked well after reconfiguring it for my purpose:

git branch -r | awk -Forigin/ '/\/PATTERN/ {print $2 "/" $3}' | xargs -I {} git push origin :{}

I also needed take the folder structure into account. My feature-branches are in a folder structure like origin/feature/PREFIX-FEATURENUMBER. So i had to build up my pattern from $2=folder + $3= branchname.

Everyone is using awk, not sure why. I feel like that's more complex. Here is what I use to delete all remote branches on my fork remote:

$ git branch -r --list 'fork/*' | sed 's/fork\///' | xargs git push --delete fork

Throw in a grep between the xargs and sed if you need to filter the list down to only a subset of remote branches.

I realize this is for git command, but if you looking for an alternate solution to do the similar or same result:

You can do it from here (Git Remove Remote Branches):

Then select the branches you want:

Make sure you have the permissions to remove the remote branches.

I was not able to use awk because we are using a slash structure for our branches' name.

git branch -r | grep "origin/users/YOURNAME" | sed -r 's/^.{9}//'| xargs -i  sh -c 'git push origin --delete {}'

This get all remote branch, get only the one for a single user, remote the "origin/" string and execute a delete on each of them.

Github also has a nice UI and mechanism for quickly deleting branches, that's if you'd rather use a UI

Dry run:

git branch -r --list 'origin/your-branch-name/*' | sed "s/origin\///" | xargs -I {} echo {}

Delete remote branches:

git branch -r --list 'origin/your-branch-name/*' | sed "s/origin\///" | xargs -I {} git push origin --delete {}

Delete only fully merged remote branches:

git branch -r --merged --list 'origin/your-branch-name/*' | sed "s/origin\///" | xargs -I {} git push origin --delete {}

Explanation:

sed "s/origin\///" will remove origin/ from the branch name. Without stripping that away I got: remote ref does not exist

Previous answers helped me to remove all release branches from 2018. I ran this on my windows 10 command prompt. I have installed clink, so Linux like commands works for me.

Dry Run:

git branch -a | grep -o "release-.*2018" | xargs -I {} echo {}

If dry run shows branches that are not in remote/origin. Run below git prune command to fix and check again.

git remote prune origin

Delete once you are happy with the result above:

git branch -a | grep -o "release-.*2018" | xargs -I {} git push origin --delete {}

If you see: error: unable to delete 'release-...2018': remote ref does not exist. Then run the previous prune command and try again.

I tried to delete all origin/release/r1-1* remote branches, hence following command line worked nicely.

git branch -r | awk -Forigin/ '/\/*r1-1/ {print $2}' |  xargs -I {} git push origin :{}

Good solution in case of multiple remotes where we can find few PREFIX combinations. If you have many (let's say hundreds) branches that were created automatically for example such pattern: build/XXXX. In addition, there is upstream remote and forked origin so that branch -r returns origin/build/XXXX and upstream/build/XXXX as well.

You can use solution with command cut -f2- -d/ More: https://unix.stackexchange.com/a/354984

Dry run where one can combine safe regex patterns like: 33[1-3][0-9] or [0-9]{4}:

git branch -r | grep -Eo "upstream/build/33[0-9][0-9]" | cut -f2- -d/ | xargs -I {} echo {}

The same with real delete from the upstream:

git branch -r | grep -Eo "upstream/build/33[0-9][0-9]" | cut -f2- -d/ | xargs -I {} git push upstream --delete {}

I use this to remove unwanted branches in the remote from time to time:

git branch -r --list origin/some/prefix/* | sed 's/origin\///' | xargs git push origin --delete

where brnaches starting with some/prefix are the unwanted ones.

This:

• handles branches with (multiple) / in their names and
• updates the list of remote branches (so git remote update origin --prune is not needed after running this)

Example:

git branch -r --list origin/bug/* | sed 's/origin\///' | xargs git push origin --delete

Deletes all branches starting with 'bug/'