How to Delete a Git Branch: Local, Remote & Stale Refs

Hitting enter on a destructive command in your terminal is definitely nerve-wracking, especially when you are not a hundred percent sure which branch you are actually about to drop. It’s way too easy to nuke days or weeks of unmerged progress if you mix up a local branch with a remote-tracking one. Let’s walk through how to clean up your branches safely, keep your workspace tidy, and pull your work back from the dead if you ever mess up.

• Local safe delete: git branch -d branch_name
• Local force delete: git branch -D branch_name
• Remote delete: git push origin --delete branch_name
• Clean up stale tracking: git fetch --prune
• Undo / Recovery: git reflog

The Pre-Delete Safety Checklist

Jumping straight into deletion commands without checking your surroundings first is asking for trouble. Before you start ditching any branches, take a quick second to see where your HEAD pointer is currently resting and make sure you are standing in a safe spot.

Fire up your terminal, type git status, and hit Enter. Make sure your working tree is nice and clean without any half-baked edits hanging around uncommitted. On top of that, check that you aren’t actively sitting on the branch you want to trash. Hop back over to your default branch by running git checkout main (or master, depending on your project) before doing anything else.

How to Delete a Local Git Branch

Remember that your local machine keeps track of branch references completely separately from remote hosts like GitHub or GitLab. Pulling the plug on a branch on your laptop won’t touch or alter anything sitting up on the remote server.

Safe Deletion (-d) vs. Force Deletion (-D)

Git comes with a built-in seatbelt so you don't accidentally trash work that hasn't been merged yet. Sticking with the lowercase flag is always the smart first move. Just run git branch -d feature_branch to try deleting it safely. If that branch has any commits that aren’t folded into your current branch yet, Git will pump the brakes, refuse to delete it, and throw a clear warning.

Now, if you intentionally want to toss that experimental work in the bin and don't care about keeping those unmerged commits, you can break out the uppercase flag. Running git branch -D feature_branch tells Git to bypass the safety check and wipe the local pointer immediately, no questions asked.

Dealing with the "Cannot delete branch you are currently on" Error

Sooner or later, Git is going to shout at you with an error saying you can't delete the branch you're currently standing on. It makes sense: Git won't let you saw off the tree branch while you're still perched on it. You need to hop over somewhere else first.

Just run git checkout main or jump to any other branch in your repo. As soon as you're checked out somewhere else, rerun your delete command and it will go right through.

By the way, if you only need to fix a quick spelling blunder rather than scrapping the whole branch, take a look at how to rename a Git branch first before you blow it away.

How to Delete a Remote Git Branch

Scrubbing a branch off your local disk still leaves the remote version sitting untouched on your shared repo. You have to push an explicit instruction up to the server telling it to delete that specific branch out of the remote registry.

The Standard Push Delete Command

The cleanest, most readable way to knock out a remote branch is by using the explicit delete flag. Open your console, type git push origin --delete feature_branch, and hit Enter.

Git will reach out to the server, find the matching branch on origin, and wipe it clean. You’ll see a little confirmation line pop up in your console letting you know the remote reference was successfully deleted.

The Short Syntax Trick

If you like shortcuts and prefer typing fewer keystrokes, there is an older shorthand trick using a colon. It does the exact same thing behind the scenes.

Type git push origin :feature_branch into your terminal and send it. What this actually does under the hood is push "nothing" directly into the remote branch slot, which tells Git on the remote end to wipe it out.

Deleting Branches Right in GitHub and GitLab

You don't always need to stay glued to the terminal to clean things up. The web UI gives you a clear visual overview of what's going on, which can feel much safer when you're on a shared work laptop or doing a quick pass right after reviewing pull requests.

Deleting a Branch on GitHub

Head over to your repo on GitHub and click on the Branches tab right above the file tree, just under the repo heading. GitHub groups all your active branches together so they're easy to browse. Look up the branch you're ready to remove and click the little trash can icon on the far right. GitHub removes the remote branch right then and there, and even leaves an "Undo" popup visible for a few seconds just in case you clicked by mistake.

You can also handle this straight from the pull request conversation view. Once a PR gets merged or closed, GitHub helpfully drops a purple Delete branch button at the bottom of the thread. In fact, that’s how most engineering teams keep feature branches from piling up.

Deleting a Branch on GitLab

In your GitLab project, head over to the left-hand navigation menu and choose Repository > Branches. You'll get a clean table listing every branch alongside who committed last and when. Click the three dots over on the right edge of the branch row, then hit Delete branch. GitLab will double-check with a confirmation prompt before it actually wipes it.

You can take care of this inside merge requests on GitLab as well. When you're ready to merge an MR, just tick the Delete source branch box before hitting the button, or click the delete button that shows up on the page right after the merge completes.

Clearing Out Ghost / Stale Remote-Tracking Branches

When someone on your team deletes a feature branch up on GitHub, your local Git won't pick up on that change automatically. Your machine hangs onto cached local snapshots called remote-tracking branches. That’s why you’ll still see those phantom branches cluttering up your list whenever you run git branch -a, until you tell Git to sweep them up.

Fetch Prune vs. Remote Prune vs. Plain Prune

A lot of write-ups mix up these three cleanup commands, which causes plenty of confusion. Knowing what each one does makes it much simpler to keep your local repo tidy without second-guessing yourself.

Run git fetch --prune to refresh your tracking references against the remote server. Git checks what's actually still alive upstream, and if a branch was deleted on the remote, it cleans out the stale local tracker automatically. In day-to-day dev work, this is the command you’ll reach for almost every single time.

Running git remote prune origin does the exact same cleanup, but it specifically limits the prune check to your origin remote rather than pulling in all configured remotes across the board.

Running plain git prune is a totally different beast and has nothing to do with branch names. It is an internal garbage collection utility that sweeps up dangling, unreferenced Git objects that have been orphaned from history. You almost never have to touch this by hand.

How to Batch Delete All Merged Branches at Once

After a sprint or two of steady shipping, your local branch list can become a chaotic mess. Going through and deleting dozens of old, merged branches one by one is tedious busywork. You can easily sweep them all out in one shot with a quick piped command.

A Reliable One-Liner for Batch Cleanup

Open your terminal, ensure you are checked out on main, and run this command: git branch --merged main | grep -v main | xargs git branch -d

Here is what happens across that pipeline in a split second. First, it grabs all local branches that are already safely merged into main. Then, grep -v main strips your main branch out of that list so you don’t accidentally touch it. Finally, it feeds that filtered list straight into the safe delete command, clearing out all your old feature branches in a flash.

Recovering an Accidentally Deleted Git Branch

Every single developer deletes the wrong branch at some point in their career. The silver lining is that Git almost never destroys your commits immediately on deletion. You usually have a solid 90-day grace period where those dangling commits stay cached locally before the automatic garbage collector cleans them out for good.

Using Git Reflog as Your Safety Net

Your local repository quietly keeps a timestamped diary tracking every single movement of your HEAD pointer across commits, resets, and branch switches. That diary is your reflog.

Type git reflog into your terminal and take a look. You’ll see a running history of your recent moves, with a short commit hash sitting next to each one. Just scan backwards through the log until you see the commit or message you were working on before the deletion, and copy that hash.

Then run git checkout -b recovered_branch_name commit_hash, swapping in the hash you just grabbed. Git will bring that exact commit back to life as a brand new branch, along with all the code you thought you lost.

Protected Branches and Permission Denials

Protected branches are safeguards that repository admins turn on to prevent anyone from accidentally deleting or force-pushing over crucial branches like main or production. If you try to wipe out a branch with these protections enabled, Git will immediately reject your command with an error.

On GitHub, you'll see something like: remote: error: GH006: Protected branch update failed for refs/heads/main. To deal with this, an admin needs to head into Settings > Branches, locate the matching branch protection rule, and tweak or remove it before that branch can be removed. Keep in mind only people with admin rights can make this change.

Over on GitLab, the message looks more like: remote: GitLab: You are not allowed to delete protected branches from this project. Someone with Maintainer permissions or higher has to navigate over to Settings > Repository > Protected Branches, find the branch in the list, and hit the Unprotect button before Git will let anyone delete it.

If Git blocks you from deleting a branch that you didn't expect to be locked down, talk to your lead or team admin before turning off the rule. Those guardrails are there for a reason - mainly to keep anyone from accidentally blowing away production code.

Automating Branch Cleanup

Cleaning up merged branches manually is repetitive, and it's easy to forget to do it. You can easily set your hosting platform to handle this housekeeping in the background as soon as work gets merged.

Turning on Auto-Delete After Merge in GitHub

You can save yourself from running manual remote delete commands ever again with a simple toggle. Head to your repository on GitHub and click into Settings. Under the General settings tab, scroll down until you hit the Pull Requests section.

Check the box that says Automatically delete head branches. Once that is enabled, whenever a PR gets merged, GitHub will instantly delete the branch on the remote server for you. From there, all you have to do locally is run your normal fetch prune command to keep your local machine matching the remote.