For software developers working with multiple clients and projects, managing separate GitHub accounts can quickly become frustrating. Switching between GitHub accounts, handling multiple credentials, and ensuring we are pushing into the correct project with the correct GitHub account takes more time than most people expect.

On top of that, there is always the risk of pushing the code to the wrong repository with the wrong GitHub account. Humans make mistakes all the time, not a new thing, but I made a small setup for that, so I can at least save some time and not run into these kinds of problems.

I put together a simple SSH-based setup…

Here we go

Generate SSH Keys

First thing is to generate the SSH key from your local machine for the GitHub accounts you need to manage. Use the following commands for that.

ssh-keygen \
  -t ed25519 \
  -C "your_email@example.com" \
  -f ~/.ssh/id_ed25519_accountname

# Here you need to use the email of GitHub account you need

Example:

I need to connect 2 accounts with 2 different emails as follows

ssh-keygen \
  -t ed25519 \
  -C "shiv@gmail.com" \
  -f ~/.ssh/id_ed25519_shiv_personal

ssh-keygen \
  -t ed25519 \
  -C "client@gmail.com" \
  -f ~/.ssh/id_ed25519_shiv_client

Check here, we have used the different emails shiv@gmail.com and client@gmail.com, and we have also used the respective names as the account name id_ed25519_shiv_personal and id_ed25519_shiv_client.

Load the Keys into the SSH Agent

Now that we have created the keys, we need to load those keys into the SSH agent, which we are going to use in a while. For that, we have simple commands for that as follows:

# To start the SSH agent 
eval "$(ssh-agent -s)"

# To load the Keys into the agent
ssh-add ~/.ssh/id_ed25519_accountname

In our example, we need to run the following commands in a sequence.

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519_shiv_personal
ssh-add ~/.ssh/id_ed25519_shiv_client

Note here that we have used the same account name as we used in the previous step, which is very important.

Register the Public Key on GitHub

As we have created the SSH key and its related public key, we need to register it on GitHub. Let’s get the public key first by making the following command

cat ~/.ssh/id_ed25519_accountname.pub

Here, the cat command will print/display the public key in the terminal. Let’s do this command for our example.

cat ~/.ssh/id_ed25519_shiv_personal.pub
cat ~/.ssh/id_ed25519_shiv_client.pub

Here also, please make sure that we are using the same account name which we mentioned in the earlier commands.

Now we need to copy and paste into the SSH config of GitHub. For that, we need to navigate to the GitHub page.
Profile > Settings > SSH and GPG keys

Here we need to create a New SSH key, and there we need to paste the public key which we have created in the last step. Make sure to give this key a Proper name with your Machine identification, so in the future you can make a reference to the machine and its key.

Configure the SSH Client

Now, as we have created the SSH key in GitHub, we need to create its client to connect our local machine to the GitHub account.

For that, first we need to check if the ~/.ssh/config file exists or not. This file is used to define the SSH client. If this file does not exist, we need to create a new one with the following command.

touch ~/.ssh/config

This command will create a ~/.ssh/config file. In my case, I already have this file, so I need to open this file and make a configuration for the SSH client in it.

To open this file, we have the nano command as follows:

nano ~/.ssh/config

# Account name git
Host github-accountname
 HostName github.com
 User git
 IdentityFile ~/.ssh/id_ed25519_accountname
 IdentitiesOnly yes

Here we define distinct hosts for each GitHub account, linking each host to its corresponding private key in ~/.ssh/config file. Here, the Host alias is a key element. It will refer to the correct associated GitHub client.

In our example, we have 2 GitHub examples, so our ~/.ssh/config will look something like this

# Shiv Personal git
Host github-shiv-personal
 HostName github.com
 User git
 IdentityFile ~/.ssh/id_ed25519_shiv_personal
 IdentitiesOnly yes

# Shiv Client git
Host github-shiv-client
 HostName github.com
 User git
 IdentityFile ~/.ssh/id_ed25519_shiv_client
 IdentitiesOnly yes

Save and close the configuration file by pressing Ctrl + X, then press Y to confirm the changes, and finally press Enter to save the file.

Here, please also note that we have made a change in the Host alias, along with the key name, as per the GitHub account. Here, github-shiv-personal and github-shiv-client are the Host alias for the respective account names _shiv_personal and _shiv_client

Verify the SSH Connection

We have successfully created the SSH client with the related Host alias. Let’s verify the connection.

For that, we have a separate dedicated command in use as follows.

ssh -T git@github-hostname

# response | Hi username! You've successfully authenticated...

Let’s also check for our two example GitHub account configurations, also with the following command in sequence execution.

ssh -T git@github-shiv-personal
ssh -T git@github-shiv-client

We should be seeing the successful authentication message; if not, please re-verify the steps that we have discussed. There might be a typo or a step is missing.

So far, we have made an SSH authentication configuration for the two separate GitHub accounts using the SSH client and public key.

Clone or Update the Repository URL

Let’s now make a pull of the repository with the configuration that we have just made:

To clone the repository, we need to use the following command:

git clone git@github-accountname:username/repo.git

Let me clear a few things here, that github-accountname will be the Host alias, which we have mentioned in the config file. Along with that, the mention of the username in this command refers to the username of your GitHub account.

So, let’s make a clone of the repository using our example GitHub accounts as follows:

git clone git@github-shiv-personal:shivghari/shiv-portfolio.git
git clone git@github-shiv-client:shivclient/client-portfolio.git

Here, we have already cloned different repositories using separate SSH keys, each linked to a different GitHub account.

Before we wrap up, let’s look at a common scenario. If you already have a repository cloned locally and want it to use the new SSH configuration, you’ll need to update the Git remote origin for that repository.

For that, we have the following command in use already:

 git remote set-url origin git@github-accountname:username/repo.git

For our example, let’s assume we have a repository already. We might hit the following command in the terminal to connect it to the SSH config.

git remote set-url origin git@github-shiv-personal:shivghari/shiv-portfolio.git
git remote set-url origin git@github-shiv-client:shivclient/client-portfolio.git

Lastly, update the repository-level Git configuration by setting the appropriate username and email for the current repository so that it matches the corresponding GitHub account.

For that, we have simple git commands in use as follows:

git config user.name "Your Name"
git config user.email "your_email@example.com"

Here we can change the username and email in the different repositories as needed. Note that this username will be displayed in your commit as the author on GitHub.

Conclusion

That’s it. With this setup in place, each GitHub account remains isolated, repositories use the correct credentials automatically, and managing multiple client projects becomes much simpler.

A small configuration change, but one that can save a lot of confusion in day-to-day development.