Multiple GitHub accounts on the same computer?

By creating different host aliases to github.com in your ~/.ssh/config, and giving each host alias its own ssh key, you can easily use multiple github accounts without confusion. That’s because github.com distinguishes not by user, which is always just git, but by the ssh key you used to connect. Just configure your remote origins using your own host aliases.”

The above summary is courtesy of comments on the blog post below.

I've found this explanation the clearest. And it works for me, at least as of April 2012.

http://net.tutsplus.com/tutorials/tools-and-tips/how-to-work-with-github-and-multiple-accounts/

• Go to ~/.ssh
• Create a file named config(have no extension )

• Open config file & add below codes. (change according to your account)

  1. Account 1

     # account_1
     Host gitlab.com-account_1
     HostName gitlab.com
     User git
     PreferredAuthentications publickey
     IdentityFile ~/.ssh/id_rsa_account_1
     

  2. Account 2

     # Account2
     Host gitlab.com-Account2
     HostName gitlab.com
     User git
     PreferredAuthentications publickey
     IdentityFile ~/.ssh/id_rsa_Account2
     

  3. Account 3

     # Account_3
     Host github.com-Account3
     HostName github.com
     User git
     PreferredAuthentications publickey
     IdentityFile ~/.ssh/id_rsa_Account_3
     

• Add remote url as follows

  1. Account 1

     git remote add origin git@gitlab.com-account_1:group_name/repo_name.git
     

  2. Account 2

     git remote add origin git@gitlab.com-Account2:group_name/repo_name.git
     

  3. Account 3

     git remote add origin github.com-Account3:github_username/repo_name.git
     

Make sure that IdentityFile names are same as you created during ssh key generation.

In my case, I have my work account in Git-Lab and my personal account in GitHub. My Git-Lab account was configured globally to be accessed from all directories in my laptop like this:

git config --global user.name WORK_USERNAME
git config --global user.email WORK_USERNAME@example.com

So if you're looking for a solution without using SSL, you can do it by using git init in an empty folder, and then insert your personal account credentials in that folder:

git config user.name PERSONAL_USERNAME
git config user.email PERSONAL_USERNAME@example.com

Notice here --global is not set, because you only want your personal git to be accessed from there and not everywhere, so whatever inside that folder will have its git credentials connected to your personal account and outside of it will be connected to your work account.

After that, you can clone your repository like so git clone your_repo_link.git. Then a new window will popup and ask you to login with your github account.

To verify your process try git config --list inside the folder that you created, you should see both work and personal usernames and emails with their directories.

Outside that folder, if you run git config --list you should see your work username and email only.

That's it, hope this helps someone without configuring SSL.

I use shell scripts to switch me to whatever account I want to be "active". Essentially you start from a fresh start, get one account configured properly and working, then move the these files to a name with the proper prefix. From then on you can use the command "github", or "gitxyz" to switch:

# my github script
cd ~/.ssh

if [ -f git_dhoerl -a -f git_dhoerl.pub -a -f config_dhoerl ]
then
    ; 
else 
    echo "Error: missing new files"
    exit 1
fi 

# Save a copy in /tmp, just in case
cp id_rsa /tmp
cp id_rsa.pub /tmp
cp config /tmp
echo "Saved old files in /tmp, just in case"

rm id_rsa
rm id_rsa.pub
rm config
echo "Removed current links/files"

ln git_dhoerl id_rsa
ln git_dhoerl.pub id_rsa.pub
ln config_dhoerl config

git config --global user.email "dhoerl@<company>.com"
git config --global github.user "dhoerl"        
git config --global github.token "whatever_it_is"

ssh-add -D

I've had great luck with this. I also created a run script in Xcode (for you Mac users) so it would not build my project unless I had the proper setting (since its using git):

Run Script placed after Dependencies (using /bin/ksh as the shell):

if [ "$(git config --global --get user.email)" != "dhoerl@<company>.com" ]
then
    exit 1
fi

EDIT: added tests for new files existence and copying old files to /tmp to address comment by @naomik below.

just figured this out for Windows, using credentials for each repo:

cd c:\User1\SomeRepo
git config --local credential.https://github.com.user1 user1
git config --local credential.useHttpPath true
git config --local credential.helper manager
git remote set-url origin https://USERNAME@github.com/USERNAME/PROJECTNAME.git

The format of credential.https://github.com. tells the credential helper the URL for the credential. The 'useHttpPath' tells the credential manager to use the path for the credential. If useHttpPath is omitted then the credential manager will store one credential for https://github.com. If it is included then the credential manager will store multiple credentials, which is what I really wanted.

There are plenty of answers explaining how to accomplish what you have asked but I'd like to offer a different perspective.

I think there's something to be said for keeping work and personal stuff separate from each other. It's pretty trivial to switch between user accounts on all operating systems so you could just create separate OS accounts for work and play and have different github accounts logged in in each.

Maintaining a clear separation of concerns can also...

• prevent your work files becoming co-mingled with your personal files
• reduce the risk of carrying out an action on the wrong resource
• potentially confine security breaches to one set of accounts / credentials

In case you don't want to mess with the ~/.ssh/config file mentioned here, you could instead run git config core.sshCommand "ssh -i ~/.ssh/custom_id_rsa" in the repo where you want to commit from a different account.

The rest of the setup is the same:

1. Create a new SSH key for the second account with ssh-keygen -t rsa -f ~/.ssh -f ~/.ssh/custom_id_rsa

2. Sign in to github with your other account, go to https://github.com/settings/keys , and paste the contents of ~/.ssh/custom_id_rsa.pub

3. Make sure you're using SSH instead of HTTPS as remote url: git remote set-url origin git@github.com:upstream_project_teamname/upstream_project.git

I see a lot of possible workarounds here. As a quick fix, @Greg's one seems relatively easy. However, it's best to set up separate ssh keys for all different accounts in the long run. This video demonstrates it briefly. Here are the steps mentioned in that video blog.

Step 1 - Create a New SSH Key for a new account and save it in a separate file (e.g. ~/.ssh/id_rsa_new_account_name), not in the original file i.e. ~/.ssh/id_rsa

ssh-keygen -t rsa -C "your-email-address"

Step 2 - Attach the New Key

• Next, login to your second GitHub account
• Browse to Account Overview, and attach the new key ~/.ssh/id_rsa_new_account_name.pub within the SSH Public Keys section.
• In the Terminal, tell SSH to add the new identity by typing ssh-add ~/.ssh/id_rsa_new_account_name. If successful, you'll see a response of Identity Added.

Step 3 - Create a Config File

touch ~/.ssh/config

And save the following contents into the file

#Default GitHub
Host github.com
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_rsa

#New Account
Host github-new-account-name
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_rsa_new_account_name

Step 4 - Try it Out Now every time you want to use the new account and the associated repo, type this for the respective repo

git remote add origin git@github-new-account-name:your-domain.com/your-repo.git

Got my private repo working using SSH key pairs. This was tested on git for Windows.

Source: https://docs.github.com/en/free-pro-team@latest/github/authenticating-to-github/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent

A. Generate public and private key pairs

1. Start git bash
2. Run ssh-keygen -t ed25519 -C "your_email@example.com"
3. When you're prompted to "Enter a file in which to save the key," press Enter to accept the default.
4. Press enter for a blank passphrase.
5. Start the ssh agent: eval $(ssh-agent)
6. Add private key to ssh agent and store the passphrase: ssh-add ~/.ssh/id_ed25519

B. Add SSH keys to GitHub account

1. Copy the public key to the clipboard: clip < ~/.ssh/id_ed25519.pub
2. On GitHub, go to Profile -> Settings -> SSH Keys -> New SSH Key
3. Give a title. E.g. "Windows on MacBook Pro"
4. Paste the key and hit "Add SSH Key".

C. Test SSH connection

1. Enter: ssh -T git@github.com
2. Hit "yes" for any warning message.
3. It should show: "Hi username!..." indicating a successful test.

D. Setup local repository to use SSH keys

1. Change email and user name:

git config user.email your_email@example.com
git config user.name github_username

2. Update remote links to use git. First list remote URI's:

git remote -v
git remote set-url origin git@github.com:github_username/your-repo-name.git

E. Test

git remote show origin

another easier way is using multiple desktop apps, like what i am doing, using account A on Github desktop, while using account B on Github Kraken

The easiest and straightforward approach (IMHO) - no config files not too much hassle

Just create another ssh key.

Let's say you have aa new work GitHub account, just create a new key for it:

sh-keygen -t rsa -C "email@work_mail.com" -f "id_rsa_work_user1"`

Now you should have the old one and the new one, to see them, run:

ls -al ~/.ssh

You need to run the above only once.

From now on, every time you want to switch between the two, just run:

ssh-add -D
ssh-add ~/.ssh/id_rsa_work_user1 #make to use this without the suffix .pub

In order the switch to the old one, run again:

 ssh-add -D
 ssh-add ~/.ssh/<previous id_rsa>

Simple approach without dealing with SSH keypairs

Just change the user.name & user.email locally in the repo. to the ones you want to push to that repo with.

Example: I have a work account in gitlab having a project. After cloning this project/repo, in the terminal, I type out:

git config user.name "my-work-username"
git config user.email "my-work-email-id"

Now, say I've another personal project/repo in Gitlab that I want to associate with my personal account. Just like above, after cloning, I type:

git config user.name "my-personal-username"
git config user.email "my-personal-email-id"

Hope this helps. Upvote if it worked for you! :)

IntelliJ Idea has built-in support of that https://www.jetbrains.com/help/idea/github.html#da8d32ae

Personal Directory .gitconfig using a personal access token

If you do not want to modify your host file, use SSH keys, or setup a .gitconfig for each repo, then you may use a personal .gitconfig that you basically include from the root level config. Given an OSX directory structure like

# root level git config
~/.gitconfig

# your personal repos under some folder like
../personal/
../home/
~/Dropbox/

Add a .gitconfig in your personal folder, such as ~/Dropbox/.gitconfig

[user]
    email = first.last@home.com
    name = First Last
[credential]
    username = PersonalGithubUsername
    helper = osxkeychain

In your root level .gitconfig add an includeIf section to source your personal config whenever you are in your personal directory. Any settings there will override the root config as long as the includeIf comes after the settings you want to override.

[user]
    email = first.last@work.com
    name = "First Last"
[credential]
    helper = osxkeychain
[includeIf "gitdir:~/Dropbox/**"]
    path = ~/Dropbox/.gitconfig

Try pushing to your personal repo or pulling from your private repo

git push
# prompts for password

When prompted enter either your personal password or, better yet, your personal access token that you have created in your account developer settings. Enter that token as your password.

Assuming you are already using git-credential-osxkeychain, your personal credentials should be stored in your keychain, so two github entries will show up, but with different accounts.

Option 0: you dont want to mess around with OS settings.. you just want to commit to a different github account with a different public key for one repo.

solution:

1. create the new key: ssh-keygen -t rsa -b 4096 -f ~/.ssh/alt_rsa

2. add the key to the keyset: ssh-add -K ~/.ssh/alt_rsa

3. copy and add the pub key to the github account: (see github instructions)

4. test the key with github: ssh -i ~/.ssh/alt_rsa T git@github.com

5. clone the repo using the git protocol (not HTTP): git clone git@github:myaccount...

6. in the cloned repo:

   git config core.sshCommand "ssh -i ~/.ssh/alt_rsa -F /dev/null"
   git config user.name [myaccount]
   git config user.email [myaccount email]

7. now you should be able to git push correctly without interferring with your everyday git account

Manage multiple GitHub accounts on one Windows machine (HTTPS)

Let's say you previously use git on your machine and configure git global config file. To check it open the terminal and :

git config --global -e

It opens your editor, and you may see something like this:

[user]
    email = yourEmail@gmail.com
    name = Your_Name
...

And this is great because you can push your code to GitHub account without entering credentials every time. But what if it needs to push to repo from another account? In this case, git will reject with 403 err, and you must change your global git credentials. To make this comfortable lat set storing a repo name in a credential manager:

git config --global credential.github.com.useHttpPath true

to check it open config one more time git config --global -e you will see new config lines

[credential]
    useHttpPath = true
...

The is it. Now when you first time push to any account you will see a pop-up Screenshot_1

Enter specific for this repo account credentials, and this will "bind" this account for the repo. And so in your machine, you can specify as many accounts/repos as you want.

For a more expanded explanation you can see this cool video that I found on youtube: https://youtu.be/2MGGJtTH0bQ

Use docker!

This may not be suitable for everyone but this is what I ended up doing for myself.

All my developments are now done inside docker containers. I am a vim user but I know VSCode has plugin to work with docker containers.

So since I have different docker containers for different projects/languages, I can use different git configurations inside each. Problem solved.

just add this line in your fav editor and you are done for life

git remote set-url origin https://user-token-of-particular-user@github.com/profile-name/repo-name

Unlike other answers, where you need to follow few steps to use two different github account from same machine, for me it worked in two steps.

You just need to :

1) generate SSH public and private key pair for each of your account under ~/.ssh location with different names and

2) add the generated public keys to the respective account under Settings >> SSH and GPG keys >> New SSH Key.

To generate the SSH public and private key pairs use following command:

cd ~/.ssh
ssh-keygen -t rsa -C "email@work.com" -f "id_rsa_WORK"
ssh-keygen -t rsa -C "email@gmail.com" -f "id_rsa_PERSONAL"

As a result of above commands, id_rsa_WORK and id_rsa_WORK.pub files will be created for your work account (ex - git.work.com) and id_rsa_PERSONAL and id_rsa_PERSONAL.pub will be created for your personal account (ex - github.com).

Once created, copy the content from each public (*.pub) file and do Step 2 for the each account.

PS : Its not necessary to make an host entry for each git account under ~/.ssh/config file as mentioned in other answers, if hostname of your two accounts are different.

If you happen to have WSL installed you can have two seperate git accounts - one on WSL and one in windows.

You should and must not push to the project with some common credentials. Once starting on a new machine use the following steps to setup and use correctly your gitlab credentials:

• create the pubic / private ssh keys on the machine
• copy paste the public key to the gitlab/github ui interface ( anyone hinting how-to do via the cmd line gets a free beer ... )
• make sure you clone the repo via the git and not http url
• set the git alias to avoid constant typing of the same prefix to the git command
• during git commit ALWAYS use the author and e-mail flags
• use git as normal you would do it

All this as follows:

 # create the public / private key credentials on that specific machine
 ssh-keygen -t rsa -b 4096 -C "<<you>>@org.net" -f ~/.ssh/id_rsa.<<you>>.`hostname -s`

 # setup your public key in the gitlab ui 
 cat ~/.ssh/id_rsa.<<you>>.`hostname -s`

 # make sure you clone the repo via the git and not http url
 git clone git@git.in.org.net:org/some-repo.git

 # set the git alias to avoid constant typing of the repeating prefix to the git cmd
 alias git='GIT_SSH_COMMAND="ssh -i ~/.ssh/id_rsa.<<you>>.`hostname -s`" git'

 # during git commit ALWAYS use the author and e-mail flags
 git add --all ; git commit -nm "$git_msg" --author "YourFirstName YourLastName <you@phz.fi>"

 # use git as normal
 git fetch --all; git pull --all 

1. Navigate to the directory in which you want to push your changes to a different GitHub account.

2. Create a new SSH key in your terminal/command line.

   ssh-keygen -t rsa -C “your-email-address”

3. The following will then show:

   Generating public/private rsa key pair. Enter file in which to save the key (/home/your_username/.ssh/id_rsa):

Copy and paste the path followed by an identifiable name for the file:

/home/your_username/.ssh/id_rsa_personal

4) It will then ask you for the following:

Enter passphrase (empty for no passphrase):
Enter same passphrase again:

5) You can now type in the following command to see all the SSH keys you have on your local machine:

ls -al ~/.ssh

You should be able to see your new SSH key file. As you can see in my one I have both id_rsa_test and id_rsa_personal.pub.

drwx------  2 gmadmin gmadmin 4096 Nov 16 22:20 .
drwxr-xr-x 42 gmadmin gmadmin 4096 Nov 16 21:03 ..
-rw-------  1 gmadmin gmadmin 1766 Nov 16 22:20 id_rsa_personal
-rw-r--r--  1 gmadmin gmadmin  414 Nov 16 22:20 id_rsa_personal.pub
-rw-r--r--  1 gmadmin gmadmin  444 Nov  6 11:32 known_hosts

6) Next you need to copy the SSH key which is stored in id_rsa_personal.pub file. You can open this in text editor of your choice. I am currently using atom so I opened the file using the following command:

atom ~/.ssh/id_rsa_personal.pub

You will then get something similar to this:

ssh-rsa AAB3HKJLKC1yc2EAAAADAQABAAABAQCgU5+ELtwsKkmcoeF3hNd7d6CjW+dWut83R/Dc01E/YzLc5ZFri18doOwuQoeTPpmIRVDGuQQsZshjDrTkFy8rwKWMlXl7va5olnGICcpg4qydEtsW+MELDmayW1HHsi2xHMMGHlNv

7) Copy this and navigate to your GitHub account → Settings → SSH and GPG keys 8) Click on New SSH key. Copy the key, give it a title and add it. 9) Add key from terminal

ssh-add ~/.ssh/id_rsa_personal
Enter passphrase for /home/your_username/.ssh/id_rsa_personal: 

10) Configure user and password.

git config --global user.name "gitusername"
git config --global user.email "gitemail"

11) We are ready to commit and push now.

git init
git add .
git commit 
git push

If you have created or cloned another repository and you were not able to pull from origin or upstream adding the ssh key at that directory using the following command worked.

This is the error I was getting here:

Warning: Permanently added the RSA host key for IP address '61:fd9b::8c52:7203' to the list of known hosts.
Permission denied (publickey).
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.

I used the following command, this works:

ssh-add ~/.ssh/id_rsa_YOUR_COMPANY_NAME

Change the authentication method in github from SSh to HTTP. This way it will not care if you are logged with your work github account and you try to remotely interact with your personal github account (which has different credentials than the ones you are currently logged with onto your local machine).

There could be multiple way to do it but Following solution works for me and very simple. I am not trying to do it with SSH, my steps and solution is based on HTTPS.

1. Create your project DIR on your local machine. Example d:\test_git_multiple_account

2. go to the folder "test_git_multiple_account"

3. Add few files here into the DIR

4. Open Git bash here and run following command

   a. git init // initialization 
   b. git add , // add 
   c. git commit -m "initial commit"
       you will get following output : in my case i use to add one python file created 
       from code.
       **[master (root-commit) d4defd9] initial commit
       2 files changed, 4 insertions(+)
       create mode 100644 .vscode/settings.json
       create mode 100644 Hello.py**
   
   d.  git remote add origin <HTTPS repo link>
   e.  git remote -v // check the repo version 
   f.  git push origin master
       it will ask your git hub user name and password via popup screen. 
       you will get the following output 
       Counting objects: 100% (5/5), done.
       Delta compression using up to 4 threads
       Compressing objects: 100% (3/3), done.
       Writing objects: 100% (5/5), 411 bytes | 31.00 KiB/s, done.
       Total 5 (delta 0), reused 0 (delta 0), pack-reused 0
       remote:
       remote: Create a pull request for 'master' on GitHub by visiting:
       remote:      https://github.com/vishvadeepaktripathi/Hello_Py/pull/new/master
       remote:
       To https://github.com/vishvadeepaktripathi/Hello_Py.git
        * [new branch]      master -> master
   

This will create new branch as i named here called master. You can commit into main branch once you change the branch in this case your existing file will be delete. So i would recommend that to checkout into main branch into First step then proceed for every command in case you want to checkout directly into main branch. Caution At the First login it might give you an error message and ask again for login and password and then it will publish your change into Git hub.

Once this is done you will get message to new pull request into your github account. you can merge your changes from master branch to the main branch.

i created master branch here you named your branch as per your choice. Attaching the screen shot as well. enter image description here

You do not have to maintain two different accounts for personal and work. In fact, Github Recommends you maintain a single account and helps you merge both.

Follow the below link to merge if you decide there is no need to maintain multiple accounts.

https://help.github.com/articles/merging-multiple-user-accounts/

Instead you just add your new email id to your personal git account. This way you don't need to add another SSH key. Just configure your new email by doing git config --global user.email newemail. Then you will be able to clone that repo.