Adding a remote repository
To add a new remote, use the git remote add command on the terminal, in the directory your repository is stored at.
The git remote add command takes two arguments:
- A remote name, for example,
origin - A remote URL, for example,
https://github.com/user/repo.git
For example:
$ git remote add origin https://github.com/USER/REPO.git
# Set a new remote
$ git remote -v
# Verify new remote
> origin https://github.com/USER/REPO.git (fetch)
> origin https://github.com/USER/REPO.git (push)For more information on which URL to use, see «About remote repositories.»
Troubleshooting: Remote origin already exists
This error means you’ve tried to add a remote with a name that already exists in your local repository.
$ git remote add origin https://github.com/octocat/Spoon-Knife.git
> fatal: remote origin already exists.To fix this, you can:
- Use a different name for the new remote.
- Rename the existing remote repository before you add the new remote. For more information, see «Renaming a remote repository» below.
- Delete the existing remote repository before you add the new remote. For more information, see «Removing a remote repository» below.
Changing a remote repository’s URL
The git remote set-url command changes an existing remote repository URL.
The git remote set-url command takes two arguments:
- An existing remote name. For example,
originorupstreamare two common choices. - A new URL for the remote. For example:
- If you’re updating to use HTTPS, your URL might look like:
https://github.com/USERNAME/REPOSITORY.git - If you’re updating to use SSH, your URL might look like:
git@github.com:USERNAME/REPOSITORY.git
- If you’re updating to use HTTPS, your URL might look like:
Switching remote URLs from SSH to HTTPS
- Open TerminalTerminalGit Bash.
- Change the current working directory to your local project.
- List your existing remotes in order to get the name of the remote you want to change.
$ git remote -v > origin git@github.com:USERNAME/REPOSITORY.git (fetch) > origin git@github.com:USERNAME/REPOSITORY.git (push) - Change your remote’s URL from SSH to HTTPS with the
git remote set-urlcommand.$ git remote set-url origin https://github.com/USERNAME/REPOSITORY.git - Verify that the remote URL has changed.
$ git remote -v # Verify new remote URL > origin https://github.com/USERNAME/REPOSITORY.git (fetch) > origin https://github.com/USERNAME/REPOSITORY.git (push)
The next time you git fetch, git pull, or git push to the remote repository, you’ll be asked for your GitHub username and password. When Git prompts you for your password, enter your personal access token. Alternatively, you can use a credential helper like Git Credential Manager. Password-based authentication for Git has been removed in favor of more secure authentication methods. For more information, see «Creating a personal access token.»
You can use a credential helper so Git will remember your GitHub username and personal access token every time it talks to GitHub.
Switching remote URLs from HTTPS to SSH
- Open TerminalTerminalGit Bash.
- Change the current working directory to your local project.
- List your existing remotes in order to get the name of the remote you want to change.
$ git remote -v > origin https://github.com/USERNAME/REPOSITORY.git (fetch) > origin https://github.com/USERNAME/REPOSITORY.git (push) - Change your remote’s URL from HTTPS to SSH with the
git remote set-urlcommand.$ git remote set-url origin git@github.com:USERNAME/REPOSITORY.git - Verify that the remote URL has changed.
$ git remote -v # Verify new remote URL > origin git@github.com: USERNAME/REPOSITORY.git (fetch) > origin git@github.com: USERNAME/REPOSITORY.git (push)
Troubleshooting: No such remote ‘[name]’
This error means that the remote you tried to change doesn’t exist:
$ git remote set-url sofake https://github.com/octocat/Spoon-Knife
> fatal: No such remote 'sofake'Check that you’ve correctly typed the remote name.
Renaming a remote repository
Use the git remote rename command to rename an existing remote.
The git remote rename command takes two arguments:
- An existing remote name, for example,
origin - A new name for the remote, for example,
destination
Example of renaming a remote repository
These examples assume you’re cloning using HTTPS, which is recommended.
$ git remote -v
# View existing remotes
> origin https://github.com/OWNER/REPOSITORY.git (fetch)
> origin https://github.com/OWNER/REPOSITORY.git (push)
$ git remote rename origin destination
# Change remote name from 'origin' to 'destination'
$ git remote -v
# Verify remote's new name
> destination https://github.com/OWNER/REPOSITORY.git (fetch)
> destination https://github.com/OWNER/REPOSITORY.git (push)Troubleshooting: Could not rename config section ‘remote.[old name]’ to ‘remote.[new name]’
This error means that the old remote name you typed doesn’t exist.
You can check which remotes currently exist with the git remote -v command:
$ git remote -v
# View existing remotes
> origin https://github.com/OWNER/REPOSITORY.git (fetch)
> origin https://github.com/OWNER/REPOSITORY.git (push)Troubleshooting: Remote [new name] already exists
This error means that the remote name you want to use already exists. To solve this, either use a different remote name, or rename the original remote.
Removing a remote repository
Use the git remote rm command to remove a remote URL from your repository.
The git remote rm command takes one argument:
- A remote name, for example,
destination
Removing the remote URL from your repository only unlinks the local and remote repositories. It does not delete the remote repository.
Example of removing a remote repository
These examples assume you’re cloning using HTTPS, which is recommended.
$ git remote -v
# View current remotes
> origin https://github.com/OWNER/REPOSITORY.git (fetch)
> origin https://github.com/OWNER/REPOSITORY.git (push)
> destination https://github.com/FORKER/REPOSITORY.git (fetch)
> destination https://github.com/FORKER/REPOSITORY.git (push)
$ git remote rm destination
# Remove remote
$ git remote -v
# Verify it's gone
> origin https://github.com/OWNER/REPOSITORY.git (fetch)
> origin https://github.com/OWNER/REPOSITORY.git (push)Note: git remote rm does not delete the remote repository from the server. It simply
removes the remote and its references from your local repository.
Troubleshooting: Could not remove config section ‘remote.[name]’
This error means that the remote you tried to delete doesn’t exist:
$ git remote rm sofake
> error: Could not remove config section 'remote.sofake'Check that you’ve correctly typed the remote name.
Further reading
- «Working with Remotes» from the Pro Git book
Do you write code for a living? Then learn Git, and learn it well. The tool originally created by Linus Torvalds—yes, the creator of the Linux kernel—has become the de facto standard when it comes to source control solutions. To help you along your learning journey, we’ve been covering common Git pitfalls and explaining how to get out of them.
Today, we’ll add another installment to the series by covering an issue you might bump into when following Git tutorials over the web: the «remote origin already exists» error. As far as Git error messages go, this one is pretty straightforward, unlike other weirder messages. It clearly states what the problem is: you’re trying to add a remote called origin, but you already have one with that name. That’s not that different from your operating system preventing you from creating a file with the same name as an already existing file.
In this post, we’ll give more detail into why that error message happens in the first place and then show you a few different ways in which you can address it. Let’s dig in.
«Remote Origin Already Exists» Error: Why Does It Happen?
Picture this: You’re following a Git tutorial you’ve found online. So far everything works fine. Then, you see a line similar to the following one:
git remote add origin <SOME-URL>/<SOME-REPOSITORY-NAME>.git
After trying to execute the command above, you get the infamous error message:
fatal: remote origin already exists.
Understanding this message is actually easy. Unlike centralized VCSs, Git doesn’t have a central server. In Git, you can have what we call remote repositories, or simply remotes. Remotes represent repositories that you might have read and/or write access to. Those are usually on machines other than your own, and you access them via SSH or HTTP. Keep in mind that, despite the name, remotes aren’t necessarily located on remote machines: despite sounding like an oxymoron, local remotes are totally possible.
Remotes have names to identify them, and you can have as many remotes per repository as you need or want. However, you can’t have two remotes with the same name. So if you try to add a remote with the same name as an already existing remote, boom! Fatal error.
If you want to be really sure the remote called origin actually exists, you can easily check that by running the following command:
git remote
That will make your Git list all existing remotes for the current repository. If you want to get more detail, you can add the verbose parameter with the remote command, like this:
git remote -v
That will return not only the names of each remote but also its URLs:
By the way, the message will not always contain the actual word «origin.» Let’s say you’re trying to add a remote called cloudbees but there’s already a remote with that name. In this case, the error message would say:
fatal: remote cloudbees already exists.
Similarly to the way that the default branch in Git is called controller—though that could change in the near future—the default remote is called origin, but you could name it anything you like as long as it’s a legal name in Git.
Solving the «Remote Origin Already Exists» Error in Four Different Ways
Having explained why the error message happens, we’ll now cover some of the several potential solutions you can use to solve the problem. Keep in mind that the solution you’ll use will depend on your specific situation because there are a few different scenarios that can cause this problem to happen.
1. Remove the Existing Remote
The first scenario we’ll cover is the one in which there’s already a remote called origin, but it’s the wrong remote for some reason. Let’s say, for the sake of the example, that you used to use GitLab for storing your repositories online and then decided to switch over to GitHub (or vice versa). To go about that, you could follow the steps below:
-
Create a new repository online using GitHub or GitLab.
-
Go to your local repository and remove the existing origin remote.
-
Add the new online repository as the correct origin remote.
-
Push your code to the new origin.
If, for some reason, you skip step #2, that will cause Git to display the «remote origin already exists» message. So a possible solution here would be simply removing the existing remote:
git remote remove origin
As explained before, origin is just a name for a remote. It could be a different name for you. To make sure the remote is indeed deleted, you can use the Git remote command you saw earlier. Then, if everything is all right, you can go on to adding the desired remote.
2. Update the Existing Remote’s URL
We’ve just shown you how to remove an existing remote, so you can hopefully add a new one, this time with the correct URL. However, you might be thinking that removing the remote and adding it again with a different link will have an eerily similar result as updating the URL of the existing remote. If that’s the case, you’re right, of course.
So let’s see how to achieve the same result we got in the previous section but in a faster way. You just have to use a single command:
git remote set-url <REMOTE-NAME> <NEW-URL>
As we’ve said before, we keep talking about origin throughout this post, but there’s nothing preventing you from working with whatever remote names you feel like. So a complete example with origin as the remote name and a URL to a real repo could look like this:
git remote set-url origin https://github.com/git/git.git
3. Rename the Existing Remote
Let’s say that, for whatever reason, you already have a remote called origin. You want to add a new origin, but you also need to keep the old one. How would you go about it?
Easy. Rename the existing remote before adding the new one. Just run the following command and you’re set:
git remote rename <old-name> <new-name>
So let’s say you want to rename your origin remote to backup. You’d simply run:
git remote rename origin backup
Then you can add your new remote called origin normally, and you should no longer see the «remote origin already exists» error.
4. Do Nothing!
This is not a joke, I promise you. Here’s the thing: Sometimes, you might get the «remote origin already exists» error when following a tutorial that has some step asking you to add a remote called origin. If you try to run the command and get the error message, it’s possible that you’ve already executed that command and don’t remember.
To check whether that’s really the case, you can use the Git remote command with the verbose option, as we’ve covered before:
git remote -v
That will allow you to see the existing remotes along with the URLs they point to. If the existing remote already has the same URL provided by the tutorial, that means your repo is ready to go and you don’t need to do anything else.
«Remote Origin Already Exists» Scaring You? A Thing of the Past
Git is an essential tool in the modern software developer’s tool belt. Unfortunately, many developers consider Git a hard tool to learn. There’s some truth to those claims. Though the basic Git commands you’ll use most of the time are easy to learn and understand, you might stumble upon a particularly difficult aspect of the tool from time to time. For instance, you might find yourself with a somewhat bizarre error message. Or the various ways in which Git allows you to go back and change things might trip you up a bit.
In today’s post, we’ve covered a fairly common Git error message. Hopefully, you’re now ready to address this error when it comes your way.
If there’s one takeaway you get from this post, we hope it’s this: Even though Git can sometimes feel daunting, it’s actually not that hard once you get used to some of its UI quirks and get somewhat familiar with its fundamentals. So keep studying and keep practicing, and then using Git will feel like second nature in no time.
Добавил(а) microsin
Ключевое слово «origin» обычно используется для описания центрального источника (ресурса на сервере) репозитория Git. Если Вы попытаетесь добавить удаленный сервер (remote), так называемый «origin» к репозиторию, в котором описание origin уже существует, то получите ошибку «fatal: remote origin already exists». В этой статье (перевод [1]) мы обсудим подобный случай проблемы «fatal: remote origin already exists» и способ её решения.
Ошибка Git «fatal: remote origin already exists» показывает вам, что Вы пытаетесь создать remote с именем «origin», когда remote с таким именем уже существует (был прописан ранее). Это ошибка — общий случай, когда вы забыли, что уже настроили ссылку на remote репозиторий, и снова выполняете инструкции по установке. Также эту ошибку можно увидеть, если делается попытка поменять URL «origin» remote-репозитория командой git remote add.
Чтобы исправить эту ошибку, нужно сначала проверить, связан ли в настоящий момент remote с ключевым словом «origin», и что у него корректный URL. Вы можете сделать это командой git remote -v:
m:asmradiopager>git remote -v origin https://github.com/microsindotnet/git (fetch) origin https://github.com/microsindotnet/git (push)
Если «origin» URL не соответствует URL Вашего remote-репозитория, к которому Вы хотите обратиться, то можно поменять remote URL. Альтернативно можно удалить remote, и заново установить remote URL с именем «origin».
Пример проблемной ситуации. У нас есть некий репозиторий с именем «git», и мы хотим поменять его текущий origin:
https://github.com/microsindotnet/git
На новый origin:
https://github.com/microsindotnet/gitnew
Чтобы сделать это, мы используем команду git remote add command, который добавляет новый remote к репозиторию:
git remote add origin https://github.com/microsindotnet/gitnew
Но эта команда вернула ошибку:
fatal: remote origin already exists.
Этим сообщением git говорит нам, что remote origin уже существует.
Способ решения проблемы. Мы не можем добавить новый remote, используя имя, которое уже используется, даже если мы указываем для remote новый URL. В этом случае мы попытались создать новый remote с именем «origin», когда remote с таким именем уже существует. Чтобы исправить эту ошибку, мы должны удалить существующий remote, который называется «origin», и добавить новый, либо должны поменять URL существующего remote.
Чтобы удалить существующий remote и добавить новый, мы можем установить новый URL для нашего remote:
git remote set-url origin https://github.com/microsindotnet/gitnew
Это предпочтительный метод, потому что мы можем в одной команде поменять URL, связанный с нашим remote. Не понадобится уделить старый origin и создавать новый, потому что существует команда set-url.
Альтернативно мы можем удалить наш remote «origin», и после этого создать новый, с новым URL:
git remote rm origin git remote add origin https://github.com/microsindotnet/gitnew
Этот метод использует 2 команды вместо одной.
[Ссылки]
1. Git fatal: remote origin already exists Solution site:careerkarma.com.
2. git: быстрый старт.
What is the ‘fatal: remote origin already exists’ error?
fatal: remote origin already exists is a common Git error that occurs when you clone a repository from GitHub, or an external remote repository, into your local machine and then try to update the pointing origin URL to your own repository.
In the context of Kubernetes, the error can occur when you configure orchestrations to include Git repositories. For example, by using: git remote add origin [url].gits
fatal: remote origin already exists is caused by the cloned repository already having a URL configured. Specifically, a URL that leads to the original profile where the repository source is.
What is a remote origin in Git?
remote origin, as the name implies, is the place where code is stored remotely. It is the centralized server or zone where everyone pushes code to and pulls code from.
Remote repositories are versions of your project hosted on Git-compatible platforms such as GitHub, Bitbucket, GitLab, and Assembla. origin is the standard and generic handle that is used to associate the host site’s URL.
For example, you can have an alternative remote URL called dev, which then becomes the handle for a separate repository but for the same code.
When you run git remote -v, you will get a list of handles and associated URLs. So if you have different handlers for the same remote, the console output could look something like this:
D:GitHubgit remote -v origin https://github.com/prod_repo/projectx.git (fetch) origin https://github.com/prod_repo/projectx.git (push) dev https://github.com/dev_repo/projectx.git (fetch) dev https://github.com/dev_repo/projectx.git (push)
This means that you can run the following command: git push dev master
The changes made will get pushed up to the master branch at the URL associated with dev and not origin.
Resolving ‘fatal: remote origin already exists’
For most development environments, origin is the default handler used. Here are 3 ways to resolve fatal: remote origin already exists.
1. Remove the Existing Remote
remote refers to the hosted repository. origin is the pointer to where that remote is. Most of the time, origin is the only pointer there is on a local repository.
If you want to change the pointing URL attached to origin, you can remove the existing origin and then add it back in again with the correct URL.
To remove your handler, use the remove command on remote, followed by the handler name – which, in our case, is origin.
Here is an example: git remote remove origin
To check that handler is deleted properly, run the following: git remote -v
You will either get an empty list, or you will get a list of remote handlers that are currently attached to the project with origin removed from the list.
Now you can run git remote add origin [url].git without encountering the fatal: remote origin already exists error.
2. Update the Existing Remote’s URL
You are not always required to remove the origin handler from remote. An alternative way to solve fatal: remote origin already exists is to update the handler’s pointing URL.
To do this, you can use the set-url command, followed by the handler name (which is origin in our case) and the new URL.
Here is the syntax for updating an existing origin URL: git remote set-url origin [new-url]
Once this is completed, you can now push and pull code from the newly configured Git repository location.
3. Rename the Existing Remote
Alternatively, you can rename origin to something else. This means that instead of deleting the handler’s pointing URL to make room for the new one, you can rename it and keep the original details.
To do this, use the rename command on: remote.
For example, if you want to rename origin to dev, you can use the following command: git remote rename origin dev
Now when you run git remote -v, you will get dev as the handler instead of origin.
D:GitHub[some-repo]git remote -v dev https://github.com/some_repo/projectx.git (fetch) dev https://github.com/some_repo/projectx.git (push)
This will give you room to add a new origin to the list of attached handlers. So when you run git remote add origin [url].git, you will no longer get the fatal: remote origin already exists error prompt.
How to prevent ‘fatal: remote origin already exists’
To prevent fatal: remote origin already exists error from occurring, you can check if the origin handler already exists. If it does not, running the git add remote origin command should not produce this issue.
The most important thing to note here is that origin is only a handler’s short name. It is a reference to the URL, which is where the actual remote repository is hosted.
The handler origin just happens to be the standardized default. This is what makes fatal: remote origin already exists so common. The error itself can occur against any handler, provided that it has the same placeholder name.
To check if origin even exists, run git remote -v to get a list of current remote handlers and the associated URLs.
If origin exists, you can do one of the following:
- remove
originfrom theremotelist viaremovecommand, like so:git remote remove origin - update origin pointing URL with
set-url, like so:git remote set-url origin [new-url] - rename the existing
originhandler to something else viarenamecommand:git remote rename origin [new-name]
K8s troubleshooting with Komodor
We hope that the guide above helps you better understand the troubleshooting steps you need to take in order to fix the fatal: remote origin already exists 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 and 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.
This article discusses how to resolve the issue git fatal: remote origin already exists error during the push or add commands.
Fix git fatal: remote origin already exists error on push
You must run the ‘git init’ command to enable git for any application or folder/directory.
Once git is initialized, we must either create a new repository or clone an existing repository to map this to the existing directory.
if this directory is created in the nested folder of any git repository, the git command throws git fatal: remote origin already exists error.
What does its origin mean?
This error comes during multiple use cases.
- created a local nested folder app, It is a child folder of a local git repository, these folders map to the new remote repository.
B:blogjswork>git remote add origin https://github.com/intkiran/react-auth0-login.git
fatal: remote origin already exists.
An error would
fatal: remote origin already exists.
From the above code, It creates an origin local name and adds it to an existing repository.
In any local repository, How do you know the remote repository url?
using the -v option gives the local name with a remote url as described following
And the output is
origin https://github.com/intkiran/react-auth0-login.git (fetch)
origin https://github.com/intkiran/react-auth0-login.git (push)
It gives the remote repository url mapped with the local name i.e origin.
Origin is the local name for the remote repository given by default.
This error occurs after adding a new url to the existing origin.
This post covers the solution for the following errors in the git command
- fatal: No such remote:
- Remote origin already exists on ‘git push’ to a new repository
There are many ways we can fix this.
Remove the original name from the given existing repository
First, delete the local name origin for a given remote repository using the following command.
next, add the original name to the new remote repository
git remote add origin remote-repo-url
set-url Change origin name from the given existing git repository
git remote set-url neworigin remote-repo-url
if remote-repo-url does not exist, it gives an error fatal: No such remote:.
Replace current origin with new url in Git
below set the new url for the local name origin.
git remote set-url origin remote-repo-url
rename existing origin name in Git
The last approach is to rename the existing origin to the new name
git remote rename origin neworigin
Finally, Verify the name mapped to the URLs using the below command.
wrap
There are many ways we can fix these errors with the above solutions.
“fatal: remote origin already exists” problem, you get this git error when you try to create a link to a remote repository called “origin” when another remote repository with that name already exists.
The answer is to alter the URL of the remote repository with the name “origin” to the URL of the remote repository you want to add, rather than trying to establish a new remote repository with the name “origin.”
You can do so with the following command:
git remote set-url origin https://github.com/your/repository You may configure your local repository wrong if you don’t completely comprehend the instructions you’re doing, or if you cloned a repository that already has a remote with the name “origin” configured.
Let’s take a closer look at remote repositories so you don’t make the same mistake again. The most typical cause of this problem is a misunderstanding of one or more of the following: what a remote repository is, how the remote command works, or, more specifically, what the “origin” aspect of these instructions means.
Why Does the «Remote Origin Already Exists» Error Occur?
Consider the following scenario: You’re working through a Git instruction that you discovered online. So far, everything has gone smoothly. Then you come upon a line that looks like this:
git remote add origin <Your-URL>/<Your-REPOSITORY-NAME>.git When you try to run the command above, you get the dreaded error message:
fatal: remote origin already exists. This message is actually quite simple to comprehend. Git does not have a central server, unlike centralized VCSs. Remote repositories, or simply remotes, are what we call them in Git. Remotes are repositories to which you may have read and/or write permissions.
These are normally located on machines other than your own, and you can connect to them using SSH or HTTP. Keep in mind that, despite their name, remotes aren’t always found on remote machines: local remotes, although sounding like an oxymoron, are entirely feasible.
Remotes have names to help you recognise them, and you can have as many as you need or wish per repository. You can’t have two remotes with the same name, though. So, if you try to add a remote with the same name as an existing remote, you’ll get an error message. A fatal blunder.
If you wish to double-check if the remote called origin exists, use the following command:
This will cause your Git to display a list of all available remotes for the current repository. If you want extra information, use the verbose parameter with the remote command, such as this:
This will yield the names of each remote as well as their URLs:
origin https://github.com/your/repository (fetch)
origin https://github.com/your/repository (push) By the way, the phrase “origin” will not always appear in the message. Assume you’re trying to add a codeleaks remote, but there’s already one with that name. The error message in this scenario would be:
fatal: remote codeleaks already exists. The default remote is called origin, just like the default branch in Git is called controller—though that could change in the near future—but you can call it anything you want as long as it’s a legal Git name.
Four Approaches to Resolving the «Remote Origin Already Exists» Error
After explaining why, the error notice appears, we’ll go over some of the possible strategies for resolving the issue. Keep in mind that the remedy you choose will be dependent on your individual situation because this problem can occur in a variety of ways.
Approach 01: Remove the Remote that already exists
The first example we’ll look at is when a remote called origin already exists, but it’s the wrong remote for whatever reason. Let’s pretend you were previously using GitLab to store your online repositories and then switched to GitHub (or vice versa). You could do so by following the instructions below:
- Using GitHub or GitLab, create a newbit online repository.
- Remove the existing origin remote from your local repository.
- Assign the correct origin remote to the new online repository.
- Your code will be pushed to the new origin.
If you omit step #2 for whatever reason, Git will display the “remote origin already exists” message. As a result, simply deleting the existing remote could be a viable option:
As previously stated, origin is simply a term for a distant. For you, it could be a different name. You can use the Git remote command, which you saw before, to verify that the remote has been destroyed. After that, if everything looks good, you can proceed to adding the chosen remote.
Approach 02: Update the URL of Existing Remote
We just showed you how to remove an existing remote, so perhaps you can install a new one with the correct URL this time. However, you may believe that removing the remote and re-adding it with a different link will have a result that is eerily similar to changing the URL of the original remote. Of course, if that’s the case, you’re correct.
So, let’s see how we can get the same outcome as we did in the previous section, but in a shorter amount of time. You only need to use one command:
git remote set-url <REMOTE-NAME> <NEW-URL> We’ve already mentioned that we’ll be talking about origin throughout this post, but there’s nothing stopping you from using whatever remote names you choose. So, using origin as the remote name and a URL to a real repo, a complete example may look like this:
git remote set-url origin https://github.com/git/git.git Approach 03: Rename the Remote that already exists
Let’s imagine you already have a remote called origin for any reason. You’d want to add a new origin, but you’d like to maintain the previous one as well. What would you do if you had to do it?
Easy. Before you add the new remote, rename the old one. All you have to do now is run the following command:
git remote rename <old-name> <new-name> Let’s imagine you wish to rename your backup remote to origin remote. You’d simply take off:
git remote rename origin backup Then you can add your new remote called origin as usual, and the “remote origin already exists” error should be gone.
Approach 04: Don’t need to do Anything
I promise you, this isn’t a joke. But here’s the deal: When following a tutorial with a step that asks you to add a remote called origin, you may get the “remote origin already exists” issue. If you try to run the command and receive an error message, it’s possible you’ve previously done it and aren’t aware of it.
You can use the Git remote command with the verbose option to see if that’s the case, as we’ve seen before:
You’ll be able to see all of the existing remotes, as well as the URLs they link to. If the existing remote already has the same URL as the tutorial, your repo is ready to use and there is no need to do anything else.
«Remote Origin Already Exists» Nothing to get Panic
Git is a must-have in the toolkit of any modern software engineer. Unfortunately, many engineers regard Git as a difficult technology to master. Those assertions include some truth.
Though the most common Git commands are simple to learn and understand, you may come into a particularly challenging component of the tool from time to time. You might, for example, receive a strange error message. Or you can be tripped up by the different ways Git allows you to go back and tweak things.
Conclusion
In conclusion, we discussed how to fix the git error fatal: remote origin already exists. We deconstructed the notion of Git remote repositories and went over a few of the most frequent commands you’ll need to know in order to use them effectively.