Git Delete Branch: How to Remove Local and Remote Branches

Deleting A Local Git Branch

Deleting a local branch is not difficult; luckily, it’s one of the more straightforward Git tasks. Let’s review the safest way to do it and what to watch out for.

The basic command to delete a local branch

The safest way to delete a local branch is with the -d flag:

git branch -d <branch_name>

Keep in mind that this command only works if the branch has been fully merged into the current branch (typically main or master). If there are any unmerged changes, Git will stop you to prevent accidental data loss.

Force deleting a local branch

If you try to delete a branch that still has unmerged changes, Git won’t let you unless you force it:

git branch -D <branch_name>

The -D flag (notice the uppercase) skips the safety check and deletes the branch immediately, whether it’s merged or not. I would highly advise exercising caution with this. Any unmerged work will be lost unless you have a backup or another branch pointing to the same commits.

Checking for unmerged changes before deletion

Before you arrive at the point of deleting a branch, it’s a good idea to check if it has unmerged changes. You can do this with:

git branch --no-merged

The above command lists all branches that haven’t been merged into the current branch. If the one you’re about to delete appears in this list, double-check that you don’t need any of its changes before proceeding.

Want a quick reference for Git commands, including deleting branches? Download the handy Git Cheat Sheet.

Deleting A Remote Git Branch

Deleting a remote branch is a bit different from deleting a local one. Since remote branches exist in shared repositories, removing them helps keep things organized and prevents outdated branches from cluttering up team workflows.

The basic command to delete a remote branch

To delete a branch from a remote repository like GitHub, GitLab, or Bitbucket, use:

git push origin --delete <branch_name>

This command removes the branch reference from the remote repository, making it inaccessible to others. However, any local copies of the branch on other machines won’t be affected they’ll need to be cleaned up separately.

Verifying remote branch deletion

After deleting a remote branch, you’ll need to confirm that it’s actually gone. First, fetch the latest updates from the remote repository:

git fetch --prune

This removes outdated remote-tracking references. To double-check that the branch is no longer listed, run the following:

git branch -r

The above command displays all remaining remote branches. If the deleted branch still shows up, try running another git fetch --prune or ensure the deletion command was executed on the correct remote.

Best Practices For Deleting Git Branches

Deleting branches is a routine part of working with Git, but doing it the right way can save you from unnecessary headaches. Here are some best practices to keep your repository organized and avoid potential mistakes.

Avoid deleting unmerged branches prematurely

Before deleting a branch, make sure it doesn’t contain any unmerged work that’s still needed. If you're unsure, check its status with:

git branch --no-merged

If the branch has valuable changes that haven't been merged, consider merging or archiving them first instead of deleting them outright.

Delete after merging

Once a feature or fix has been merged into the main branch (main or master), there’s no reason to keep the old branch around. Deleting merged branches helps prevent clutter and makes it easier to see which branches are still active.

Communicate with your team

As a professional courtesy, when you’re working on a collaborative project, avoid deleting a branch without warning your team. It can cause confusion—or worse, disrupt someone else’s work. Before removing a remote branch, check with your team to ensure no one is still using it. I prefer a simple Slack message or note to prevent frustration.

Before deleting a branch, you might want to tidy up your commit history by squashing commits. Learn how in our Git Squash Commits tutorial.

Common Issues When Deleting Git Branches

Deleting branches in Git is usually problem-free, but there are a few common pitfalls that can trip you up. Here’s what to watch out for and how to handle these issues should they come up.

Deleting a branch that’s not fully merged

Again, if you try to delete a branch that still has unmerged changes using git branch -d, Git will stop you to prevent potential data loss. This is a fail-safe. Any unmerged work will be lost if you force delete it with -D.

If you’ve already deleted a branch and realize you need it back, you may be able to recover it using Git’s reflog:

git reflog
git checkout -b <branch_name> <commit_hash>

This lets you restore the branch from its last known commit if it hasn’t been completely lost to garbage collection.

Deleting the current branch

Git won’t let you delete the branch you’re currently on, which makes sense otherwise, you’d be left without an active branch. If you see an error when trying to delete a branch, switch to another branch first:

git checkout main

Or, if using Git 2.23+:

git switch main

Once you're on a different branch, you can safely delete the one you intended to remove.

Need to switch between branches before deleting one? Our guide on checking out a remote branch in Git walks you through the process.

Accidentally deleting a remote branch

If a remote branch was deleted by mistake, you can restore it (assuming you still have a local copy) by pushing it back to the remote:

git push origin <deleted_branch_name>

This recreates the branch on the remote repository, restoring collaborators' access. If no local copy exists, you may need to manually check your commit history and recreate the branch.

Why Can't I Delete A Git Branch?

If you're having trouble deleting a branch in Git, revisit the common issues; check if it’s fully merged, you’re on the branch currently, or it’s a remote branch. From here, it may be your settings or permissions.  

1. The first thing to check is whether you're currently on that branch. Git won’t let you delete a branch you’re actively working on, so you’ll need to switch to a different branch first. 
2. If that’s not the issue, the branch might still have unmerged changes. Git protects branches with unmerged work, so unless you're absolutely sure you don’t need those changes, you’ll need to merge or force-delete the branch using git branch -D branch-name.
3. If you’re trying to delete a remote branch, a simple git branch -d won’t do the trick. Instead, you’ll need to run git push origin --delete branch-name, and to clean up old references, you can use git fetch --prune. 
4. Some repositories, especially those hosted on platforms like GitHub or GitLab, have protected branches that can't be deleted without changing the settings. If you're working in a shared repository, you may also need the right permissions to delete branches.

Still stuck? Running git branch -v can give you more details on the branch’s status and help you figure out what’s going on before trying again.

Automating Branch Cleanup With Git

I love good automation. While manually deleting branches works fine, and you should understand how to do it, there is another way. If you’re dealing with a lot of branches (like in a team setting), automation can save time and keep things tidier. Git offers a few ways to streamline branch cleanup, reducing clutter without extra effort.

Automate remote branch cleanup

When a remote branch is deleted, your local Git still holds onto a reference to it until you update things manually. Instead of cleaning them up one by one, you can use:

git fetch --prune

The above command automatically removes local references to branches that no longer exist on the remote repository, keeping everything in sync. Running this regularly prevents outdated branches from piling up in your local repo.

Use Git hooks for cleanup

For teams or larger projects, Git hooks can help automate branch cleanup. Hooks are custom scripts that run at certain points in the Git workflow, like after merging a branch. You can configure a post-merge hook to automatically delete merged branches after a set period, ensuring old branches don’t linger unnecessarily.

Conclusion

Branches can get messy over time, but a bit of “trimming” helps keep your repository clean and your workflow efficient. By making a habit of deleting merged branches, double-checking unmerged ones and keeping communication open in team projects, you can avoid these issues. And if you want to take it a step further, automation tools like git fetch --prune and Git hooks can help keep your repo clean without extra effort.

Deleting branches is just one step toward mastering Git. To deepen your understanding of version control, check out the Intermediate Git course. If you're working with GitHub repositories, a solid grasp of GitHub’s core concepts is essential. Learn more in the Introduction to GitHub Concepts course!