Sometimes, Git can’t make your change to a remote repository without losing commits. When this happens, your push is refused.
If another person has pushed to the same branch as you, Git won’t be able to push your changes:
$ git push origin main
> To https://github.com/USERNAME/REPOSITORY.git
> ! [rejected] main -> main (non-fast-forward)
> error: failed to push some refs to 'https://github.com/USERNAME/REPOSITORY.git'
> To prevent you from losing history, non-fast-forward updates were rejected
> Merge the remote changes (e.g. 'git pull') before pushing again. See the
> 'Note about fast-forwards' section of 'git push --help' for details.
You can fix this by fetching and merging the changes made on the remote branch with the changes that you have made locally:
$ git fetch origin
# Fetches updates made to an online repository
$ git merge origin YOUR_BRANCH_NAME
# Merges updates made online with your local work
Or, you can simply use git pull
to perform both commands at once:
$ git pull origin YOUR_BRANCH_NAME
# Grabs online updates and merges them with your local work
When collaborating with other developers using Git, you might encounter the error: failed to push some refs to [remote repo]
error.
This error mainly occurs when you attempt to push your local changes to GitHub while the local repository (repo) has not yet been updated with any changes made in the remote repo.
So Git is trying to tell you to update the local repo with the current changes in the remote before pushing your own changes. This is necessary so that you don’t override the changes made by others.
We’ll be discussing two possible ways of fixing this error in the sections that follow.
We can fix the error: failed to push some refs to [remote repo]
error in Git using the git pull origin [branch]
or git pull --rebase origin [branch]
commands. In most cases, the latter fixes the error.
Let’s go over how you can use the commands above.
How to Fix error: failed to push some refs to
Error in Git Using git pull
To send a pull request means to «fetch» new changes made to the remote repo and merge them with the local repo.
Once the merging is done, you can then push your own code changes to GitHub.
In our case, we’re trying to get rid of the error: failed to push some refs to [remote repo]
error by sending a pull request.
Here’s how you can do that:
git pull origin main
If you’re working with a different branch, then you’d have to replace main
in the example above with the name of your branch.
Just keep in mind that there are chances of failure when using this command to sync your remote and local repos to get rid of the error. If the request succeeds, then go on and run the command below to push your own changes:
git push -u origin main
If the error persists, you’ll get an error that says: fatal: refusing to merge unrelated histories
. In that case, use the solution in the next section.
How to Fix error: failed to push some refs to
Error in Git Using git pull --rebase
The git pull --rebase
command is helpful in situations where your local branch is a commit behind the remote branch.
To fix the error, go on and run following commands:
git pull --rebase origin main
git push -u origin main
If the first command above runs successfully, you should get a response that says: Successfully rebased and updated refs/heads/main
.
The second command pushes your local repo’s current state to the remote branch.
Summary
In this article, we talked about the error: failed to push some refs to [remote repo]
error.
This error occurs when you attempt to push your local changes to the remote repo without updating your local repo with new changes made to the remote repo.
We discussed two commands that you can use to fix the error: the git pull origin [branch]
and git pull --rebase origin [branch]
commands.
I hope this helps you fix the error.
Happy coding!
Learn to code for free. freeCodeCamp’s open source curriculum has helped more than 40,000 people get jobs as developers. Get started
What is ‘failed to push some refs to’ error
failed to push some refs to is a Git error that many developers frequently face. It occurs when a developer attempts to push committed code to an external git repository. The ability to push code stopped working suddenly, despite it working yesterday or the day before. It can be a source of frustration and annoyance for many.
failed to push some refs to errors are often caused when changes are not committed before pushing, issues with Git pre-push hook, incorrect branch name, or the local repository not being in sync with the Git repository. It occurs most of the time because multiple contributors are working on the same branch and the remote repository is further along than what you currently have on your local machine.
It is easy for git pushes to overlap when working in teams or for ref heads to be in different positions. This overlap can cause the repository to be out of sync, which is why the failed to push some refs to error are so frequent.
What causes ‘failed to push some refs to’ error
When multiple developers work on the same branch, it can cause a sequencing issue in Git. A commit gets rejected and causes a failed to push some refs to
error because the remote branch contains code that you do not have locally. What this means is that your local git repository is not compatible with the remote origin.
Here is an abstraction of what incompatibility looks like in Git:
A -- B -- C -- D (on the remote) A -- B -- E (on your local machine)
Based on the above, your local machine is missing commits C and D. Meanwhile, you are trying to slot in your commit – E – between B and C on the remote.
Before Git lets you proceed, you will need to integrate the remote changes into your local repository. This step will fix any incompatibility issues and ensure that your version is up to date with the remote.
How can you fix ‘failed to push some refs to’ errors
Here are the scenarios that may cause the failed to push some refs
error, and how to correct them:
1.Another developer pushed a commit to the same branch
The error in your terminal looks like this:
To [email protected]:sometest.git ! [rejected] your-branch -] your-branch (non-fast-forward)
When this occurs, the head sits at different positions on the same code timeline, and Git does not know how to handle it. This is because the origin
repository is ahead of where you currently are. To fix this issue, run git pull
on your local repository. This should allow you to push to origin again.
git pull origin [your-branch] git push origin [your-branch]
2. You got a ‘master (non-fast-forward)’ error with a ‘failed to push some refs to’ error
A git fast-forward
happens when the ref pointer gets moved forward in the commit history. However, if your code diverges before it reaches the latest commit, it can cause the non-fast-forward
issue and lead to a failed to push some refs to
error.
To solve this issue, you can pull with the --rebase
flag. --rebase
will let you move your intended files to commit over to the latest pull code.
Here is how to pull with --rebase
:
git pull --rebase origin [branch]
3. You got a ‘master (fetch first)’ error with a ‘failed to push some refs to’ error
When this occurs, someone has pushed to the branch before you. Git wants you to pull first before you can push your committed changes.
To prevent the loss of your work during the pull
, you can stash
your local changes.
The common suggested fix is to use --force
flag to push through the local changes. However, it is good practice to avoid using the --force
flag as it can cause inconsistency issues. Instead, use --rebase
to move the ref
heads and update your local repository without causing a divergence in the remote repository.
Using --force
to try and fix the failed to push some refs to
error will only result in more errors in the long run. This occurs because --force
uses a brute force method that puts your current code and its ref
head as the source of truth.
As a result, the changes in the remote can be overwritten by what you have pushed, removing any features or updates that other developers may have committed.
Only use --force
if you are comfortable with features not on your local being overwritten with what you’ve currently got. Use the --force
flag if you are confident that your local repository in its current state is correct.
How to prevent ‘failed to push some refs to’ errors
To prevent failed to push some refs to
errors in Git, it is good practice to avoid having multiple developers work on the same branch simultaneously. Instead, use feature branches that merge into a master branch or something equivalent.
If you get a failed to push some refs to
error, the main thing to do is git pull to bring your local repo up to date with the remote. Avoid employing the --force
flag when using git pull
and prevent other developers’ accidental overwrites of committed features.
Use the --rebase
flag instead to avoid other errors from occurring while fixing your original failed to push some refs to
error.
Kubernetes Troubleshooting with Komodor
We hope that the guide above helps you better understand the troubleshooting steps you need to fix the failed to push some refs to
error.
Keep in mind that this is just one of many Git errors that can pop up in your K8s logs and cause the system to fail. Due to the complex and distributed nature of k8s,
the search for the root cause of each such failure can be stressful, disorienting, and time-consuming.
This is why we created Komodor, which acts as a single source of truth (SSOT) to streamline and shorten your k8s troubleshooting processes. Among other features, it offers:
- Change intelligence: Every issue is a result of a change. Within seconds we can help you understand exactly who did what and when.
- In-depth visibility: A complete activity timeline, showing all code and config changes, deployments, alerts, code diffs, pod logs, etc. All within one pane of glass with easy drill-down options.
- Insights into service dependencies: An easy way to understand cross-service changes and visualize their ripple effects across your entire system.
- Seamless notifications: Direct integration with your existing communication channels (e.g., Slack) so you’ll have all the information you need, when you need it.
When working with Git, facing errors isn’t really uncommon. We run into random bugs and glitches just because we missed a slash here or a comma there.
In this article, we’re taking a look at the “failed to push some refs to remote git” error, its causes and how you can fix the problem.
Also read: How to fix Gitignore not working issue?
Why does this error happen?
It’s hard to pinpoint the exact cause of the error “failed to push some refs to remote git” as it’s caused by several reasons, the most popular ones being:
- Incorrect change ID in the commit.
- Lack of text files.
- Incorrect branch name format.
- Out of sync local repository.
- Git pre-push hook issues.
- Not committing initial changes before pushing them.
How to solve this?
Here are a few solutions you can try to solve the error failed to push some refs to remote git.
Check the repository pair
First up, you should check if you’ve got an incorrect repository pair. This means that the name of your local repository should match that of the Git remote repository.
If your Git repository is incorrectly named, follow this guide to delete the local repository and make a new one with the correct name.
Pull first
Before you can push new changes to a remote repository, you need to run a pull operation first. Run the following commands one at a time and try pushing to the repository again.
git pull -rebase origin [branch name]
git push origin [branch name]
Check branch names
Using incorrect branch names can also cause this error a lot of times. It’s not uncommon to make typos, so ensure you’ve got the branch’s name right, whether it’s a local or remote branch.
This can also be extended to whether or not a branch exists before you start pushing. Check to make sure you’ve got the name right, the directory isn’t empty and that the branch actually exists.
Check the working directory
Some platforms like GitHub and BitBucket don’t allow users to commit to an empty directory. If you’re using these platforms, make sure to add a file or two before you start pushing your code. This should resolve the error failed to push some refs to remote git.
Also read: GitHub vs Git vs GitLab vs Bitbucket
Someone who writes/edits/shoots/hosts all things tech and when he’s not, streams himself racing virtual cars.
You can contact him here: [email protected]
You are here: Home / Solution / Git failed to push some refs
At some point when pushing your code to a remote server (e.g. GitHub, Bitbucket, GitLab) you’re going to see an error like the following
To github.com:salcode/myrepo.git
! [rejected] master -> master (non-fast-forward)
error: failed to push some refs to 'git@github.com:salcode/myrepo.git'
hint: Updates were rejected because the tip of your current branch is behind
hint: its remote counterpart. Integrate the remote changes (e.g.
hint: 'git pull ...') before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.
The important part here is “Updates were rejected because the tip of your current branch is behind its remote counterpart.”
How did this happen?
Typically, someone else has pushed code to your remote server that you do not yet have.
What you wanted to happen
Imagine the commits for both your local master
branch and the remote server origin/master
branch look something like
master origin/master
cem32k cem32k
b4d2o1 b4d2o1
abc123 abc123
(If viewing your Git branch as a list of commits like this seems unfamiliar, I suggest checking out my post on How to Improve Git Log)
Once you’re comfortable with the commits above, you add a new commit (dg34mp
) to your local (master
) branch.
master origin/master
dg34mp
cem32k cem32k
b4d2o1 b4d2o1
abc123 abc123
Then you use
git push
and the remote server origin/master
is brought up-to-date.
master origin/master
dg34mp dg34mp
cem32k cem32k
b4d2o1 b4d2o1
abc123 abc123
This is what we wanted to happen.
What really happened
While you were creating your new commit (dg34mp
) on your local (master
) branch, someone else added their own commit (zyx911
) to the remote server
master origin/master
dg34mp zyx911
cem32k cem32k
b4d2o1 b4d2o1
abc123 abc123
Now when you use
git push
Git says, “Whoa, hold on! I can’t add the dg34mp
commit because there is an extra commit on the remote server we haven’t taken into account!” (a.k.a. I don’t know how to handle zyx911
, “failed to push some refs”).
What do we do?
First, we make a backup copy of our master
branch, in case something goes wrong. (This isn’t strictly necessary because of git reflog, but I find making a backup branch quicker and involving less thought). Once we make this backup branch we’re going to ignore it and ultimately when we’re done with this process we can delete it.
git branch bkup
Now, we rebase our master
branch with the remote branch origin/master
.
git rebase origin/master
This replaces our local master
branch with the remote origin/master
and then adds our new commit (dg34mp
) on top.
master origin/master
dg34mp
zyx911 zyx911
cem32k cem32k
b4d2o1 b4d2o1
abc123 abc123
Now we can push our changes to the remote server (origin/master
)
git push
and there is no problem because we are simply adding our new commit (dg34mp
) to the remote branch.
Photo Credit
Marina del Castell
Reader Interactions
This post talks about how to fix a git error.
error: src refspec master does not match any
error: failed to push some refs to ‘url.git’.
Possible causes for this error for the below use cases
- Create and commit changes to the remote repository
- Push the existing repository from the command line
Here are the steps and commands for creating and cloning and committing the repository
- git init
- git add README.md
- git commit -m “Initial Changes”.
- git remote add origin https://github.com/intkiran/angular-mock-api-json.git
- git push -u origin master
error: src refspec master does not match any error: failed to push some refs to ‘url.git’
There are two use cases success
and error
flow.
Let’s see how we can reproduce these error
use cases.
These are the not correct way of adding commits and pushing changes but given an example use case how we can reproduce this error?
-
I have a local project created
angular-crud-mock-api
in theb:\githubwork
directory. -
Create an empty repository in github.com my repository url.
https://github.com/intkiran/angular-mock-api-json.git
- Now want to commit angular-curd-mock-api code changes into the Repository url
existing local application created `angular-crud-mock-api which is not synced with the GitHub repository. - Let’s see how to add these changes to the remote repository
:githubworkangular-crud-mock-api>git remote add origin https://github.com/intkiran/angular-mock-api-json.git
- Issue git push command and throws an error
B:githubworkangular-crud-mock-api>git push -u origin master
error: src refspec master does not match any
error: failed to push some refs to 'https://github.com/intkiran/angular-mock-api-json.git'
That means, we have to add the first files or directory before pushing changes.
- Add the files and directories using the below command
git add .
B:githubworkangular-crud-mock-api>git add .
warning: LF will be replaced by CRLF in angular-crud-mock-api/.browserslistrc.
The file will have its original line endings in your working directory.
It adds the changes to the local repository in git.
Now, Let’s try to push changes to the remote repository using the git push
command.
- Next, push changes using the
git push
command.
B:githubworkangular-crud-mock-api>git push -u origin master
error: src refspec master does not match any
error: failed to push some refs to 'https://github.com/intkiran/angular-mock-api-json.git'
This error throws an error and you need to use the commit command before pushing the Command.
- commit changes
Here are the committed changes to the local repository.
B:githubworkangular-crud-mock-api>git commit -m "Initial changes"
[master (root-commit) 96c6c0c] Initial changes
29 files changed, 30724 insertions(+)
How to add add,commit push Success Flow in Github
Let’s see how we can reproduce these success
use cases.
Here is a sequence of commands you need to run to avoid the error.
git remote add origin https://github.com/intkiran/angular-mock-api-json.git
git add .
git commit -m "Initial changes".
git push -u origin master
Here is the output of push changes
B:githubworkangular-crud-mock-api>git push -u origin master
Enumerating objects: 38, done.
Counting objects: 100% (38/38), done.
Delta compression using up to 4 threads
Compressing objects: 100% (34/34), done.
Writing objects: 100% (38/38), 260.09 KiB | 5.20 MiB/s, done.
Total 38 (delta 1), reused 0 (delta 0), pack-reused 0
remote: Resolving deltas: 100% (1/1), done.
To https://github.com/intkiran/angular-mock-api-json.git
* [new branch] master -> master
Branch 'master' set up to track remote branch 'master' from 'origin'.
fix git error:src refspec origin does not match any
You have to carefully check the below things to avoid this error, if you create new repo or push an existing repository,
-
You forgot to add the files before pushing changes to the master or branch
-
Missing or skipping the
git add .
orgit commit
command throws an error
Here are steps for adding the files or directories
- git commit message enclosed in
double quotes
instead ofsingle quotes
Valid
git commit -m "initial changes"
Invalid
git commit -m 'initial commit'
- Please check the branch name with the push command
Usually, we will push changes using the below command.
git push -U origin `branchame`
push command push changes from the local repo to the remote repository branchname
Please make sure that branchname
exists.
‘master ‘ is the default branch.
Here is a correct command
git push -U origin master
Possible reasons
- Branch name not found
- Branch name spelling mistake or case insensitive
How to create a new repo to avoid this error in Git
here is a list of commands to avoid this error
git init
git add .
git commit -m 'message'
git push -u origin master
Conclusion
In this tutorial, Learn how to fix the git error:src refspec origin does not match any while working with git repositories.