2825

I want to use a push and pull automatically in Git Extensions, Sourcetree or any other Git GUI without entering my username and password in a prompt, every time.

So how can I save my credentials in Git?

Improve this question
4

37 Answers 37

Reset to default
1
2
4542

Attention:

This method saves the credentials in plaintext on your PC's disk. Everyone on your computer can access it, e.g. malicious NPM modules.

Run:

git config --global credential.helper store

then:

git pull

provide a username and password and those details will then be remembered later. The credentials are stored in a file on the disk, with the disk permissions of "just user readable/writable" but still in plaintext.

If you want to change the password later:

git pull

Will fail, because the password is incorrect, git then removes the offending user+password from the ~/.git-credentials file, so now re-run:

git pull

to provide a new password so it works as earlier.

Improve this answer
Sign up to request clarification or add additional context in comments.

25 Comments

for Debian/Ubuntu use libsecret stackoverflow.com/questions/36585496/…
Note that this will store your username and password in a plain text file at ~/.git-credentials. Anyone can open it and read it.
and use this if you want to forget : git config --global credential.helper forget
I think it's worth pointing out that one may want to skip the --global to only store the password for one repository (when pulling and pushing) but not for any other repository (which might be on a different hoster, with different credentials that one might not want to store for whatever reasons)
@RoboAlex's comment is popular but the protections on ~/.git-credentials are no different than a private key like ~/.ssh/id_rsa. So if you don't have a password on your private key then ~/git-credentials is no worse than ssh keys
|
709

You can use the git config to enable credentials storage in Git.

git config --global credential.helper store

When running this command, the first time you pull or push from the remote repository, you'll get asked about the username and password.

Afterwards, for consequent communications with the remote repository you don't have to provide the username and password.

The storage format is a .git-credentials file, stored in plaintext.

Also, you can use other helpers for the git config credential.helper, namely memory cache:

git config credential.helper 'cache --timeout=<timeout>'

which takes an optional timeout parameter, determining for how long the credentials will be kept in memory. Using the helper, the credentials will never touch the disk and will be erased after the specified timeout. The default value is 900 seconds (15 minutes).

You can again use --global to define for the whole system.

git config --global credential.helper 'cache --timeout=<timeout>'

Warning: If you use this method, your Git account passwords will be saved in plaintext format, in the global .gitconfig file, e.g in Linux it will be /home/[username]/.gitconfig.

If this is undesirable to you, use an ssh key for your accounts instead.

Improve this answer

12 Comments

Wish you showed the .gitconfig file - the first command has been overwritten by the second :(
For git config credential.helper cache the passwords will not be saved to a file, only stored in memory. See: git-scm.com/docs/git-credential-cache
Does not work. Gives fatal: Authentication failed. Doesnt even ask for password.
Just as an addendum - your private ssh-key will also be stored in plaintext in a user-accessible location, so in essence the same attack surface in both cases.
Unless you put a password on your private ssh key, it is also stored in plain text, no more securely than ~/.git-credentials, by default in ~/.ssh/id_rsa. So the advice to use an ssh key as more secure, would need to specify a password-protected private key. In which case you'd have to type that password each time, defeating the original purpose, unless you cache it with ssh-agent
|
501

Recommended and secure method: SSH

Generate a key following these steps: more details

ssh-keygen -t rsa -b 4096 -C "[email protected]"

set a passphrase that protects the key and store it locally

Copy the contents of the id_rsa.pub file to your clipboard for next step

clip < ~/.ssh/id_rsa.pub

Go to github.com → Settings → SSH and GPG keys → New SSH Key. Paste they key and save it

If the private key is saved as id_rsa in the ~/.ssh/ directory, we add it for authentication as such:

ssh-add -K ~/.ssh/id_rsa

A more secure method: Caching

We can use git-credential-cache to cache our username and password for a time period. Simply enter the following in your CLI (terminal or command prompt):

git config --global credential.helper cache

You can also set the timeout period (in seconds) as such:

git config --global credential.helper 'cache --timeout=3600'
Improve this answer

19 Comments

This did not work for me, git clone still asks for the username and password
i do not recommend storing your password like this because "git config --global -l" would reveal your password on the console
This is not working for me. It is strange that it should work for anyone, since in gitconfig's specification there is no room for "password"
If you use the SSH method, you'll need to start using SSH URLs instead of git URLs - stackoverflow.com/questions/14762034/…
"An even less secure method". Have to disagree. Does anyone here realise your passwordless private ssh key (the whole point of the question is to avoid typing your password) is stored in plain text (by default in ~/.ssh/id_rsa, no more securely than ~/.git-credentials ? Also the credential.helper store method does not put the password / token in .gitconfig Also due to quirks of sites like GitHub you get more fine-grained control over permissions on a Personal Access Token than an SSH public key. So for that specific case I'd say PAT with credential helper is "more secure"
|
194
+300

Turn on the credential helper so that Git will save your password in memory for some time:

In Terminal, enter the following:

# Set Git to use the credential memory cache git config --global credential.helper cache

By default, Git will cache your password for 15 minutes.

To change the default password cache timeout, enter the following:

# Set the cache to timeout after 1 hour (setting is in seconds) git config --global credential.helper 'cache --timeout=3600'

From GitHub Help.

Improve this answer

13 Comments

you're the only one who suggested the global version which is IMPORTANT, cause it got ruined for me every time I re-cloned the repo
How to set the timeout to infinity? I never want to enter my password again.
@Avamander just replace the cache part with store. So, the full command will be: git config --global credential.helper store. Note that this will store Your password in a open-text file (without any encryption, so to say).
@Casper That doesn't work with more than one account, the password isn't fetched from the store based on the e-mail like it should, instead the first one in the list is taken.
@Avamander hm.. is that supposed to be like that or it might be a bug? What is the maximum value for the --timeout parameter?
|
136

You can edit the ~/.gitconfig file to store your credentials:

nano ~/.gitconfig

Which should already have

[user] email = [email protected] user = gitUSER

You should add the following at the bottom of this file.

[credential] helper = store

The reason I recommend this option is because it is global and if at any point you need to remove the option you know where to go and change it.

Only use this option in you personal computer.

Then when you pull | clone| enter you Git password, in general, the password will be saved in ~/.git-credentials in the format

https://gituser:[email protected]

Where DOMAIN.XXX could be github.com, bitbucket.org, or others

See the documentation.

Restart your terminal.

Improve this answer

5 Comments

Don't forget to restart git bash window. Only when I did that, it worked for me.
The other alternative not recommended would be to leave the [credential] and the git-credentials and store the password direct in the .gitconfig. Either manually or with git config ..
Restarting means exec bash
Honest question, why is sudo needed for a user-specific file?
For me the ~/.gitconfig is ignored. When I "git push" it still asks me for username: orangepi@orangepizero2w:~/argo$ git push Username for 'https://github.com':
134

After going over dozens of Stack Overflow posts, blogs, etc., I tried out every method, and this is what I came up with. It covers everything.

The vanilla DevOps Git credentials & private packages cheat sheet

These are all the ways and tools by which you can securely authenticate Git to clone a repository without an interactive password prompt.

  • SSH public keys
    • SSH_ASKPASS
  • API access tokens
    • GIT_ASKPASS
    • .gitconfig insteadOf
    • .gitconfig [credential]
    • .git-credentials
    • .netrc
  • Private packages (for free)
  • Node.js / npm package.json
  • Python / pip / eggs requirements.txt
  • Ruby gems Gemfile
  • Go go.mod

The Silver Bullet

Want Just Works™? This is the magic silver bullet.

Get your access token (see the section in the cheat sheet if you need the GitHub or Gitea instructions for that) and set it in an environment variable (both for local development and deployment):

MY_GIT_TOKEN=xxxxxxxxxxxxxxxx

For GitHub, copy and run these lines verbatim:

git config --global url."https://api:[email protected]/".insteadOf "https://github.com/" git config --global url."https://ssh:[email protected]/".insteadOf "ssh://[email protected]/" git config --global url."https://git:[email protected]/".insteadOf "[email protected]:"

Congratulations. Now any automated tool cloning Git repositories won't be obstructed by a password prompt, whether using HTTPS or either style of an SSH URL.

Not using GitHub?

For other platforms (Gitea, GitHub, and Bitbucket), just change the URL. Don't change the usernames (although arbitrary, they're needed for distinct configuration entries).

Compatibility

This works locally in macOS, Linux, Windows (in Bash), Docker, CircleCI, Heroku, Akkeris, etc.

More information

See the ".gitconfig insteadOf" section of the cheat sheet.

Security

See the "Security" section of the cheat sheet.

Improve this answer

16 Comments

What I was after was git config --global credential."https://somegithost.com".username MyUserName, which is in your cheatsheet, but not anywhere else in this answer thread. That particular solution doesn't answer the OP's question, but it answered mine, so thanks!
Finally: documentation on non-interactive global usage of an API access token for pipelines without Jenkins credentials helpers or Vault.
Not only does this not work, but now I can't commit to Git at all :-(
@MaxN It's the same. You just have one set of config options per service - so rather than only 3 for github, you'd also have 3 for gitea and 3 for gitlab, and 3 for bitbucket, etc.
OMG, it just works! I've been chasing this issue for 6 hours and then I see this post... In my case I'm configuring an automated installation of Python libraries directly from GitHub in an AWS Lambda Docker image. -- Thanks @coolaj86, you're a life saver.
|
91

I think it's safer to cache credentials, instead of storing it forever:

git config --global credential.helper 'cache --timeout=10800'

Now you can enter your username and password (git pull or ...), and keep using Git for the next three hours.

It is nice and safe.

The unit for timeout is seconds (three hours in this example).

Improve this answer

2 Comments

Please explain, where does git cache the password? It does not seem to be in a file in my home directory, it does not seem to be in a file in any cloned repository, but it must be stored somewhere because it survives a logout/login. TIA
In this case, it is stored in memory. Not as easily readable as if written on disk like with "store" option.
76

For global settings, open the terminal (from anywhere), run the following:

git config --global user.name "your username" git config --global user.password "your password"

By that, any local Git repository that you have on your machine will use that information.

You can individually configure for each repository by doing:

  • open the terminal at the repository folder.

  • run the following:

    git config user.name "your username" git config user.password "your password"

It affects only that folder (because your configuration is local).

Improve this answer

6 Comments

Isn't it dangerous having such credentials in a simple config file viewable by anyone?
your question should be for another topic. Here we discus about how to config name and password for git global and locally.
I'd just like to add that asking about possible security issues of an answer has a place here as it directly influences its quality and potentially thousands of users implementing it.
doesn't work for me , added --local tag but again nothing happens
I think @bool3max question is a fair one. No-one really answered though. git config --global is still only accessible to the user, at ~/.gitconfig, so in that sense it is probably no worse than a private ssh key (with no password protection) in your home directory, or things like ~/.aws/config for aws cli. If you used --system for git config it would be available to all users on your computer, so better not do that, and no need to, although it would still be limited to the other users on your computer.
|
69

Just put your credentials in the URL like this:

https://Username:[email protected]/myRepoDir/myRepo.git

You may store it like this:

git remote add myrepo https://Userna...

...example to use it:

git push myrepo master

Now that is to List the URL aliases:

git remote -v

...and that the command to delete one of them:

git remote rm myrepo
Improve this answer

5 Comments

You can also leave your password out of the URL so Git will ask for your password, but not your username.
It's much easy and secure to use SSH instead of HTTP. So, you could keep your Git password secret and only use your SSH-Key. Information about SSH on Git: help.github.com/en/enterprise/2.16/user/… [email protected]:Username/myRepo.git
Having your password in the url will save it to your terminal's history so this way isn't very secure.
Note that a Wiki can currently only be cloned through https, not ssh, so a solution like this can be useful there. Note also that you can use an oauth-token, which is marginally more secure that your GitHub password.
Worked with windows credential manager, was prompted by windows for the password!
65

You can use git-credential-store to store your passwords unencrypted on the disk, protected only by the permissions of the file system.

Example

git config credential.helper store git push http://example.com/repo.git Username: <type your username> Password: <type your password> [Several days later] git push http://example.com/repo.git [Your credentials are used automatically]

You can check the credentials stored in the file ~/.git-credentials.

For more information, visit git-credential-store - Helper to store credentials on disk.

Improve this answer

Comments

56

Store username and password in .git-credentials

.git-credentials is where your username and password (access token) is stored when you run git config --global credential.helper store, which is what other answers suggest, and then type in your username and password or access token:

https://${username}:${password_or_access_token}@github.com

So, in order to save the username and password (access token):

git config --global credential.helper store echo "https://${username}:${password_or_access_token}@github.com" > ~/.git-credentials

Replace ${username} with your username, ${password_or_access_token} with your password (not recommended) or your access token.

NOTE that you must provide access token if you enabled 2FA on GitHub.

Using access token is recommended.

This is very useful for a GitHub robot, e.g. to solve Chain automated builds in the same Docker Hub repository by having rules for different branch and then trigger it by pushing to it in the post_push hook in Docker Hub.

An example of this can be seen here on Stack Overflow.

Improve this answer

13 Comments

Thanks, you're a life savior! We can also set https://${access_token}:${access_token}@github.com
@LucasMendesMotaDaFonseca access token can be used as username???
From all the different solutions, this is the one that worked for me. thank you!
@MichaelN Hmmm so it doesn't work with https:// prefix on your system? Which git and os are you using?
@MichaelN I've clarified the instruction and now it should be clear on how to save the password and username.
|
38

Apart from editing the ~/.gitconfig file, that you can do if you call from the command line:

git config --local --edit

or

git config --global --edit

enter image description here Editing git config file in default text editor

You can also use the command line to edit the git config file directly (without the editor)

git config --local user.name 'your username' git config --local user.password 'your password'

or

git config --global user.name 'your username' git config --global user.password 'your password'

Note to always use single quotes. Your username and password may use some characters that would break your password if you use double quotes.

--local or --global means configuration parameters are saved for the project or for the OS user.

Improve this answer

6 Comments

Check also this one that explains even more.
Are you sure single quotes will work on Windows, other than inside WSL?
I usually do things from Windows PowerShell and this single quote worked on Windows (no WSL).
What is "the os user"? Do you mean by "the OS user"? (OS = operating system). If so, what does that mean? Or something else? Can you rephrase?
The first sentence is close to incomprehensible. Can you rephrase, please? (But without "Edit:", "Update:", or similar - the answer should appear as if it was written today.)
|
35

As of 2021, there is a secure user-friendly cross-platform solution for HTTPS remotes. No more typing passwords! No more SSH keys! No more personal access tokens!

Install Git Credential Manager developed by GitHub (downloads). It supports passwordless in-browser OAuth authentication to GitHub, BitBucket, Azure and GitLab. This means you can enable two-factor authentication on GitHub and the other platforms, greatly improving the security of your accounts.

When you push, you are offered a choice of authentication methods:

> git push Select an authentication method for 'https://github.com/': 1. Web browser (default) 2. Device code 3. Personal access token option (enter for default): 1 info: please complete authentication in your browser...

On Linux, a tiny bit of setup is required. The following caches credentials in memory for 20 hours, so you have to authenticate at most once per day.

git-credential-manager configure git config --global credential.credentialStore cache git config --global credential.cacheoptions "--timeout 72000"

Power users familiar with gnome-keyring or KWallet may prefer to change the credential store to libsecret.

Cosmetic configuration (docs):

  1. Prefer choosing authentication method at terminal rather than in GUI (fewer clicks)
  2. Always use browser method rather than be asked every time (even fewer keypresses)
git config --global credential.guiPrompt false git config --global credential.gitHubAuthModes browser
Improve this answer

4 Comments

I remain a huge fan of GCM but if you find it difficult to install on Linux, you can use git-credential-oauth stackoverflow.com/a/74415927/284795
With the browser option, does it automatically authenticate if you are already logged into GitHub?
@iheartcsharp yes.
Trying this on ubuntu 23.10, I had to run git-credential-manager configure because git-credential-manager-core configure isn't a thing (anymore?)
27

You will be more secure if you use SSH authentication than username/password authentication.

If you are using a Mac, SSH client authentication is integrated into the macOS keychain. Once you have created an SSH key, type into your terminal:

ssh-add -K ~/.ssh/id_rsa

This will add the SSH private key to the macOS keychain. The Git client will use SSH when it connects to the remote server. As long as you have registered your ssh public key with the server, you will be fine.

Improve this answer

6 Comments

should be k not K?
I don't think this work for https-based repositories.
This answer seems to confuse passwords (HTTPS repos) with SSH private keys.
Yes, my recommended solution is for SSH, not HTTPS. Hence, the command "ssh-add". For HTTPS it would be the solution mentioned above "git credential-osxkeychain" (on Mac).
I disagree. You can't be more secure by giving access to the host an SSH access. Using HTTP authentication, someone who steal the credentials would only have access to GitHub/GitLab. Also token are designed to have a limited life.
|
25

Just use

git config --global credential.helper store

And do the git pull. It will ask for a username and password. From now on it will not provide any prompt for username and password. It will store the details.

Improve this answer

1 Comment

You've just basically repeated the accepted answer.
23

To save your user name and user password into a GitHub account, just run these command in sequence.

git config --global user.name "userName" git config --global user.email "[email protected]" git config --global user.password "userPassword" git config --global credential.helper store git config --list --show-origin

Then generate a key using below command:

ssh-keygen -t rsa -C "[email protected]"

Note: Copy the file location where the id_rsa file gets created. Then go to that file location → open Git Bash or command prompt → Run a command - cat id_rsa.pub

The SSH key will be displayed, copy this SSH key and paste it in your GitHub or GitLab account.

Improve this answer

Comments

15

Check official Git documentation:

If you use the SSH transport for connecting to remotes, it’s possible for you to have a key without a passphrase, which allows you to securely transfer data without typing in your username and password. However, this isn’t possible with the HTTP protocols – every connection needs a username and password. This gets even harder for systems with two-factor authentication, where the token you use for a password is randomly generated and unpronounceable.

Fortunately, Git has a credentials system that can help with this. Git has a few options provided in the box:

  • The default is not to cache at all. Every connection will prompt you for your username and password.

  • The “cache” mode keeps credentials in memory for a certain period of time. None of the passwords are ever stored on disk, and they are purged from the cache after 15 minutes.

  • The “store” mode saves the credentials to a plain-text file on disk, and they never expire. This means that until you change your password for the Git host, you won’t ever have to type in your credentials again. The downside of this approach is that your passwords are stored in cleartext in a plain file in your home directory.

  • If you’re using a Mac, Git comes with an “osxkeychain” mode, which caches credentials in the secure keychain that’s attached to your system account. This method stores the credentials on disk, and they never expire, but they’re encrypted with the same system that stores HTTPS certificates and Safari auto-fills.

  • If you’re using Windows, you can install a helper called “Git Credential Manager for Windows.” This is similar to the “osxkeychain” helper described above, but uses the Windows Credential Store to control sensitive information. It can be found at https://github.com/Microsoft/Git-Credential-Manager-for-Windows.

You can choose one of these methods by setting a Git configuration value:

git config --global credential.helper cache git config --global credential.helper store

From 7.14 Git Tools - Credential Storage

Improve this answer

Comments

14

In that case, you need git credential helper to tell Git to remember your GitHub password and username by using following command line:

git config --global credential.helper wincred

And if you are using a repository using an SSH key then you need the SSH key to authenticate.

Improve this answer

2 Comments

wincred is obsoleted, see stackoverflow.com/a/53184233/5281824
To add to what @weaming said, on Windows, manager-core is now bundled with the Git installer for Windows github.com/microsoft/Git-Credential-Manager-Core
14

None of the previous answers worked for me. I kept getting the following every time I wanted to fetch or pull:

Enter passphrase for key '/Users/myusername/.ssh/id_rsa':

For Macs

I was able to stop it from asking my passphrase by:

  1. Open config by running: vi ~/.ssh/config
  2. Added the following: UseKeychain yes
  3. Saved and quit: Press Esc, and then enter :wq!

For Windows

I was able to get it to work using the information in this Stack Exchange post: How to avoid being asked passphrase each time I push to Bitbucket

Improve this answer

1 Comment

that's because you are using SSH protocol (other answers use HTTPS).
14

Save the username and password globally:

git config --global user.name "fname lname" git config --global user.email "[email protected]" git config --global user.password "secret"

Get a specific setting,

git config --global --get user.name git config --global --get user.email git config --global --get user.password

Getting all Git settings:

git config --list --show-origin
Improve this answer

2 Comments

I have done all the settings globally, username, email, and password, still when I push the code on GitHub, It asks for the username and password every time
Yes, there are multiple places git settings are saved. Maybe in project .git folder some project settings are defaulted and take precedence.
13

If security is not a concern for the Git client, edit the URL this way:

git remote set-url origin https://${access_token}@github.com/${someone}/${somerepo}.git

The same in the git clone case:

git clone https://${access_token}@github.com/${someone}/${somerepo}.git

I personally do not favor git config with global domain, since that would be a mess in a multiple-accounts case.

access_token is what you could generate in Settings / Developer settings / Personal access tokens. Remember to grant it with repo scope.

Improve this answer

1 Comment

If security were not a concern, there would not be a need for a credential helper.
12

From the comment by rofrol, on Linux Ubuntu, from this answer, here's how to do it on Ubuntu:

sudo apt-get install libsecret-1-0 libsecret-1-dev cd /usr/share/doc/git/contrib/credential/libsecret sudo make git config --global credential.helper /usr/share/doc/git/contrib/credential/libsecret/git-credential-libsecret

Some other distributions provide the binary, so you don't have to build it.

In OS X, it typically comes "built" with a default module added of "osxkeychain", so you get it for free. Both the OS X built-in one and the homebrew variety have it present by default.

Improve this answer

Comments

12

git config --global credential.helper store is the way to do it!

Here are correct steps:

On Azure click on clone repo -> Generate Git Credentials: enter image description here

It will generate password that you just copy to your clipboard

Then follow these steps:

$ git config --global credential.helper store $ git clone https://[email protected]/myorg/my_project/_git/my_repo Cloning into 'my_repo'... Password for 'https://[email protected]': <Paste here password you've copied on your clipboard> remote: Azure Repos remote: Found 152 objects to send. (108 ms) Receiving objects: 100% (152/152), 60.89 KiB | 432.00 KiB/s, done. Resolving deltas: 100% (35/35), done. $ cd my_repo/ $ git pull Already up to date.

Notice that for last git command (i.e. git pull) it didn't ask password.

Improve this answer

Comments

11

After reading the answers in full and experimenting with most of the answers to this question, I eventually found the procedure that works for me. I want to share it in case someone has to deal with a complex use case, but still do not want to go through all the answers and the gitcredentials, gitcredentials-store etc. man pages, as I did.

Find below the procedure I suggest IF you (like me) have to deal with several repositories from several providers (GitLab, GitHub, Bitbucket, etc.) using several different username / password combinations. If you instead have only a single account to work with, then you might be better off employing the git config --global credential.helper store or git config --global user.name "your username" etc. solutions that have been very well explained in previous answers.

My solution:

  1. Unset global credentials helper, in case some former experimentation gets in the way :)

    git config --global --unset credentials.helper

  2. Move to the root directory of your repo and disable the local credential helper (if needed)

    cd /path/to/my/repo git config --unset credential.helper`

  3. Create a file to store your repo's credentials into

    git config credential.helper 'store --file ~/.git_repo_credentials'

    Note: this command creates a new file named ".git_repo_credentials" into your home directory, to which Git stores your credentials. If you do not specify a file name, Git uses the default ".git_credentials". In this case simply issuing the following command will do:

    git config credential.helper store

  4. set your username

    git config credential.*.username my_user_name

    Note: using "*" is usually ok if your repositories are from the same provider (e.g. GitLab). If instead your repositories are hosted by different providers then I suggest to explicitly set the link to the provider for every repository, like in the following example (for GitLab):

    git config credential.https://gitlab.com.username my_user_name

At this point, if you issue a command requiring your credentials (e.g. git pull), you will be asked for the password corresponding to "my_user_name". This is only required once because git stores the credentials to ".git_repo_credentials" and automatically uses the same data at subsequent accesses.

Improve this answer

3 Comments

just to note, here when using * I got: "warning: url has no scheme: * fatal: credential url cannot be parsed: *" . So I had to specify "credential.github.com.username".
(stackoverflow comment replaced the https://github... with github... in my last comment)
The best flexible option to work with several git providers from a single computer.Thanks. If anyone is looking for this behaviour using ssh keys, check your ~/.ssh/config file and add custom ssh key to be used each git server provider
9

The GitHub recommendations have now changed, and the best method is also the simplest. Details are here.

  1. Install the GitHub official CLI. E.g., for Mac: brew install gh.
  2. type gh auth login in your terminal, and then follow the prompts.
Improve this answer

Comments

9

For Windows users, look at the .gitconfig file and check what has been configured for the credential helper. If you have the following...

[credential "helperselector"] selected = wincred

you'll find the credentials in the Windows Credential Manager.

Enter image description here

There you can edit the credential.

Note: Windows Credential Manager (executable wincred) has been deprecated. See:

Git Credential Manager for Windows - "This project is no longer being maintained. "

So alternatively you may want to reconfigure Git to use the built-in Git credential manager...

git config --global credential.helper manager
Improve this answer

5 Comments

I am having an issue with the manager-core helper, where my credentials disappear every day - Any clue on how to solve this?
The edit was the answer I was looking for, THANKS!
@Jonathan The Credential manager bundled with Git for Windows changed a few times recently so the easiest option is to just download the newest Git for Windows and install over the top and select the credential manager in the installer. The credential manager is a separate utility, which you can see it on GitHub at github.com/microsoft/Git-Credential-Manager-Core, but better to just let the Git for Windows installer, install it, so you know you have version compatibility
The link is broken (404).
This was the only command that worked for me in Windows, however after running it I had to do a 'git fetch' and 'git pull origin main' to get the Windows creds window to pop up. Seems to be cached since 👍
8

If you are using the Git Credential Manager on Windows...

git config -l should show:

credential.helper=manager

However, if you are not getting prompted for a credential then follow these steps:

  1. Open Control Panel from the Start menu
  2. Select User Accounts
  3. Select Manage your credentials in the left hand menu
  4. Delete any credentials related to Git or GitHub

Also ensure you have not set HTTP_PROXY, HTTPS_PROXY, NO_PROXY environmental variables if you have proxy and your Git server is on the internal network.

You can also test Git fetch/push/pull using git-gui which links to credential manager binaries in C:\Users\<username>\AppData\Local\Programs\Git\mingw64\libexec\git-core

Improve this answer

Comments

4 
git config --global user.name "your username" git config --global user.password "your password"

Check

git config --list
Improve this answer

2 Comments

Please note that this answer states that this is an insecure way of doing this.
What is the secure way Please share secure way some hint Eric Aya
4

Two-factor authentication has changed how users authenticate to websites, but Git still assumes users can type a password from memory.

Introducing git-credential-oauth: a Git credential helper that securely authenticates to GitHub, GitLab, Bitbucket and other forges using OAuth.

No more passwords! No more personal access tokens! No more SSH keys!

The first time you push, the helper will open a browser window to authenticate. Subsequent pushes within the cache timeout require no interaction.

Install from the binaries or source at hickford, git-credential-oauth.

Configure with:

git config --global --unset-all credential.helper git config --global --add credential.helper "cache --timeout 7200" # Two hours git config --global --add credential.helper oauth
Improve this answer

3 Comments

Very nice: a good alternative to GCM on Linux indeed.
git: 'credential-oauth' is not a git command. See 'git --help'.
@DollarAkshay make sure the git-credential-oauth binary is in the PATH, and that it is executable
4

Sudheer Singh's answer did not work for me completely. I figured I had to complete the "Testing your SSH connection". After the usual

git config --global user.name "userName" git config --global user.email "[email protected]" git config --global user.password "userPassword" git config --global credential.helper store git config --list --show-origin

I copied my public key to github account. Obtain your public key like this on your PC:

ssh-keygen -t rsa -b 4096 -C "[email protected]" clip < ~/.ssh/id_rsa.pub

There is where you copy it on github.com → Settings → SSH and GPG keys → New SSH Key.

Then I ran ssh -T [email protected]. Finally, it works then.

I copied few commands from this answer as they are standard commands.

Improve this answer

Comments

1
2

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.