Support for Password Authentication Was Removed

by

If you’ve tried pushing or pulling code from a Git repository on platforms like GitHub, GitLab, or Bitbucket and seen the error “Support for password authentication was removed,” you’re not alone. This error, introduced by GitHub in August 2021 and adopted by other platforms, means you can no longer use your account password for Git operations over HTTPS. In 2025, with heightened security standards and widespread adoption of secure authentication methods, understanding and resolving this error is crucial for developers.

Why Does the “Support for Password Authentication Was Removed” Error Happen?

In 2021, GitHub discontinued password-based authentication for Git operations over HTTPS to enhance security, and other platforms like GitLab and Bitbucket followed suit. Passwords are vulnerable to brute-force attacks, phishing, and leaks, especially over HTTPS. Instead, platforms now require more secure methods like:

  • Personal Access Tokens (PATs): A secure alternative to passwords for HTTPS.
  • SSH Keys: A cryptographic method for authenticating Git operations.
  • Git Credential Managers: Tools that handle authentication securely.

The error appears when you try to use a username and password in commands like:

git push origin main

For example, if you enter your GitHub password, you’ll see:

remote: Support for password authentication was removed on August 13, 2021.
remote: Please use a personal access token or SSH key instead.
fatal: unable to access 'https://github.com/username/repo.git/': The requested URL returned error: 403

In 2025, with Git being a cornerstone of development workflows, fixing this error is essential for seamless coding. Let’s walk through the solutions.

Step-by-Step Guide to Fix the Error

Here are the most effective ways to resolve the “Support for password authentication was removed” error, starting with the easiest methods.

Method 1: Use a Personal Access Token (PAT) for HTTPS

A PAT acts like a password but is more secure and can be scoped to specific permissions. Here’s how to set it up for GitHub (similar steps apply to GitLab and Bitbucket).

Step 1: Generate a Personal Access Token

  1. Log in to GitHub: Go to github.com and sign in.
  2. Access Settings:
    • Click your profile picture (top-right) > Settings.
    • Scroll to Developer settings > Personal access tokens > Tokens (classic).
  3. Create a Token:
    • Click Generate new token (classic).
    • Give it a descriptive name (e.g., Git Authentication 2025).
    • Set an expiration (e.g., 90 days or no expiration, depending on your needs).
    • Select scopes: At minimum, check repo for full repository access. Add workflow for GitHub Actions or admin:org for organization-level access if needed.
    • Click Generate token and copy the token (e.g., ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx).
    • Save it securely: You won’t see it again, so store it in a password manager like 1Password or LastPass.

Step 2: Update Your Git Remote URL

  1. Check Your Remote URL:git remote -v You’ll see something like:origin https://github.com/username/repo.git (fetch) origin https://github.com/username/repo.git (push)
  2. Update the URL to Include the Token: Replace username with your GitHub username and your-token with the PAT:git remote set-url origin https://username:your-token@github.com/username/repo.git Example:git remote set-url origin https://johndoe:ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx@github.com/johndoe/repo.git

Step 3: Use the PAT for Git Commands

  • When running git push, git pull, or other commands, you won’t be prompted for a password if the PAT is in the remote URL.
  • Alternatively, when prompted for a password, enter the PAT instead of your GitHub password.

Step 4: Cache the PAT (Optional)

To avoid entering the PAT repeatedly, use Git’s credential helper:

git config --global credential.helper cache

Or, for persistent storage:

git config --global credential.helper store

This saves the PAT locally, so you only need to enter it once.

Pro Tip: For GitLab or Bitbucket, the process is similar. Check their documentation for generating PATs (e.g., GitLab Personal Access Tokens).

Method 2: Set Up SSH Keys for Git

SSH keys provide a secure, passwordless way to authenticate with Git repositories. They’re ideal for frequent Git users.

Step 1: Generate an SSH Key

  1. Open a Terminal:
    • Windows: Use Git Bash or PowerShell.
    • Mac/Linux: Use the terminal.
  2. Generate a Key Pair:ssh-keygen -t ed25519 -C "your.email@example.com"
    • For older systems not supporting Ed25519, use:ssh-keygen -t rsa -b 4096 -C "your.email@example.com"
    • Press Enter to accept the default file location (~/.ssh/id_ed25519 or ~/.ssh/id_rsa).
    • Optionally, set a passphrase for extra security.
  3. Start the SSH Agent:eval "$(ssh-agent -s)"
  4. Add the Private Key:ssh-add ~/.ssh/id_ed25519 Or for RSA:ssh-add ~/.ssh/id_rsa

Step 2: Add the Public Key to GitHub

  1. Copy the Public Key:cat ~/.ssh/id_ed25519.pub Copy the output (starts with ssh-ed25519).
  2. Add to GitHub:
    • Go to GitHub > Settings > SSH and GPG keys > New SSH key or Add SSH key.
    • Paste the public key, give it a title (e.g., My Laptop 2025), and click Add SSH key.

Step 3: Update Your Remote URL to Use SSH

  1. Check the Current URL:git remote -v
  2. Switch to SSH: Copy the SSH URL from your repo’s GitHub page (e.g., git@github.com:username/repo.git). Update the remote:git remote set-url origin git@github.com:username/repo.git

Step 4: Test the SSH Connection

ssh -T git@github.com

If successful, you’ll see:

Hi username! You've successfully authenticated...

Now, git push and git pull will use SSH without requiring a password.

Method 3: Use Git Credential Manager (GCM)

Git Credential Manager (GCM) simplifies authentication by handling credentials securely, especially for HTTPS.

  1. Install GCM:
  2. Configure GCM:git config --global credential.helper manager
  3. Authenticate: Run a Git command (e.g., git push). GCM will prompt you to log in via a browser or device flow, using OAuth to authenticate with GitHub, GitLab, or Bitbucket.
  4. Verify: Subsequent Git operations will use cached credentials, eliminating the error.

Pro Tip: GCM supports multi-factor authentication (MFA) and integrates with Azure AD for enterprise users.

Method 4: Use GitHub CLI or Other Tools

The GitHub CLI (gh) streamlines authentication and repository management.

  1. Install GitHub CLI:
    • Windows/Mac/Linux: Follow instructions at cli.github.com.
    • Example for Mac:brew install gh
  2. Authenticate:gh auth login Follow the prompts to log in via browser or token.
  3. Use Git Commands: The CLI configures your Git credentials automatically, so git push and git pull work without errors.

Alternative Tools:

  • GitKraken: A GUI client that handles authentication for you.
  • VS Code: Built-in Git integration with OAuth support for GitHub.

Troubleshooting Common Issues

Here’s a table of common problems and solutions when fixing the error:

IssueSolution
PAT doesn’t workEnsure the token has the correct scopes (e.g., repo). Regenerate if expired.
SSH key fails to authenticateVerify the public key is added to GitHub and the private key is loaded (ssh-add). Check SSH config (~/.ssh/config).
“Permission denied (publickey)”Ensure the SSH URL is used (git@github.com:...) and the key is correct.
GCM prompts repeatedlyRun git config --global credential.helper store or check for MFA issues.
Error persists on GitLab/BitbucketGenerate a PAT or SSH key specific to the platform and update the remote URL.

Best Practices for Secure Git Authentication in 2025

  • Use SSH for Frequent Work: SSH keys are faster and more secure for regular Git operations.
  • Rotate PATs Regularly: Set expiration dates for PATs (e.g., 90 days) and rotate them for security.
  • Enable MFA: Use multi-factor authentication on your GitHub/GitLab/Bitbucket account.
  • Store Credentials Securely: Use a password manager for PATs and avoid hardcoding them in scripts.
  • Audit Access: Regularly review SSH keys and PATs in your account settings to revoke unused ones.
  • Leverage AI Tools: Use GitHub Copilot or similar AI assistants to suggest Git commands or troubleshoot errors.

Tools to Simplify Git Authentication

  • Git Credential Manager: Automates credential handling (free).
  • GitHub CLI: Streamlines authentication and repo management (free).
  • 1Password/LastPass: Securely store PATs and SSH passphrases.
  • GitKraken: A GUI for managing Git with built-in authentication support.
  • VS Code GitLens: Visualize Git operations and manage credentials.

FAQs About the “Support for Password Authentication Was Removed” Error

Why did GitHub remove password authentication?

Passwords are less secure than PATs or SSH keys, making them vulnerable to attacks. GitHub removed password support in 2021 to enforce stronger security.

Can I still use HTTPS with Git?

Yes, but you must use a PAT or GCM instead of a password.

Is SSH better than a PAT?

SSH is faster for frequent use and doesn’t require manual token entry, but PATs are simpler for beginners or occasional use.

What if I lose my PAT or SSH key?

Regenerate a new PAT in GitHub settings or create a new SSH key pair and update your repo’s remote URL.

Final Thought: Secure Your Git Workflow

The “Support for password authentication was removed“ error is a reminder that secure authentication is critical in modern development. By switching to personal access tokens, SSH keys, or Git Credential Manager, you can resolve the error and keep your Git workflow smooth. In 2025, with tools like GitHub CLI and AI assistants, managing Git authentication is easier than ever.

Ready to fix the error? Generate a PAT or set up an SSH key today and push your code without hassle. Got a question or tip? Share it in the comments below!

Resource: For more on Git authentication, visit GitHub’s Official Documentation.

Leave a Comment