How To Create Anonymous Github Account For Open Source

Contributing to open source projects is a rewarding way to improve your coding skills, build a portfolio, and give back to the developer community. However, there are legitimate reasons why you might want to maintain separation between your professional identity and your open source work. Perhaps you’re contributing to sensitive projects, working on controversial software, or simply value keeping your coding activities private. This guide walks you through creating an anonymous GitHub account that remains unlinked from your real-world identity.

Why Create an Anonymous GitHub Account

Developers choose anonymous GitHub accounts for various reasons. Some contribute to projects related to privacy tools, security research, or advocacy work where identification could attract unwanted attention. Others maintain strict compartmentalization between their day job and personal projects. Whatever your motivation, the goal remains the same: participate in the open source ecosystem without exposing who you are.

GitHub itself requires an email address for account creation, but with careful configuration, you can prevent this email from being publicly visible and ensure your commits remain untraceable back to you.

Step 1: Create an Anonymous Email Address

The foundation of an anonymous GitHub account is an email address that cannot be traced to your real identity. Avoid using email services tied to your real name, employer, or existing online accounts. Instead, consider these options:

Proton Mail offers end-to-end encrypted email and allows sign-up without providing personal information. Create a new Proton Mail account using Tor Browser for maximum privacy. The service operates under Swiss privacy laws, providing strong legal protection for your data.

Tutanota is another privacy-focused email provider that doesn’t require phone number verification. Their free tier includes enough features for basic GitHub usage.

Self-hosted email using a custom domain provides the highest level of control. Register a domain through a privacy-aware registrar (like Njalla or OrangeWebsite) that offers domain privacy protection. Set up email forwarding to your anonymous account while keeping your real email completely separate.

When creating your email, use a pseudonym that doesn’t match your real name. Avoid reusing usernames from other platforms where your identity is known.

Step 2: Set Up Git with a Separate Identity

After creating your anonymous email, you need to configure Git to use this identity. This involves two main components: your Git user information and your SSH keys.

Configure your Git username and email specifically for the anonymous account:

git config --global user.name "pseudonym"
git config --global user.email "anonymous@your-anonymous-domain.com"

For projects requiring the anonymous identity, navigate to the repository directory and set local configuration:

cd /path/to/anonymous-project
git config user.name "dev-handle"
git config user.email "your-anonymous@proton.me"

This ensures commits from this repository use your anonymous identity, while other repositories on your machine continue using your regular identity.

Step 3: Generate New SSH Keys

Never reuse SSH keys from your main GitHub account. Generate a fresh SSH key pair specifically for your anonymous account:

ssh-keygen -t ed25519 -C "your-anonymous@proton.me"

When prompted, save the key with a descriptive name like ~/.ssh/github_anonymous. This separates it from your default SSH keys.

Add the key to your SSH agent:

ssh-add ~/.ssh/github_anonymous

Create or edit your SSH config file (~/.ssh/config) to specify which key to use for GitHub:

Host github-anonymous
    HostName github.com
    User git
    IdentityFile ~/.ssh/github_anonymous
    IdentitiesOnly yes

Now you can clone repositories using this specific SSH configuration:

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

Step 4: Create the GitHub Account

With your anonymous email and SSH keys ready, create your GitHub account:

Use Tor Browser or a VPN when signing up to mask your IP address
Provide your anonymous email address during registration
Choose a pseudonym that doesn’t reveal your identity
Skip phone number verification if possible (GitHub may require it for certain features)

After creating the account, immediately navigate to Settings → Emails and verify your anonymous email. Check the box to “Keep my email addresses private” — this hides your email from your public profile and replaces it with a no-reply GitHub address in commits.

Step 5: Add Your Anonymous SSH Key

Upload the public key you generated to your anonymous GitHub account:

cat ~/.ssh/github_anonymous.pub

Copy the output, then go to Settings → SSH and GPG keys → New SSH key. Paste the key and save.

Test the connection:

ssh -T git@github-anonymous

You should see a message confirming your anonymous identity.

Step 6: Maintain Separation

Keeping your anonymous identity separate requires ongoing vigilance. Follow these practices:

Never mix identities in the same project or on the same machine without careful git config management. Create separate working directories for anonymous work.

Use a separate browser profile for your anonymous GitHub account. Install a privacy-focused browser like Firefox with Enhanced Tracking Protection, configured with strict settings and without any sync accounts linked to your real identity.

Consider using a separate machine or VM for highly sensitive anonymous work. Tools like Qubes OS or even a simple VirtualBox VM can provide additional isolation.

Review commit history before pushing. Ensure no accidental references to your real name, email, or employer slip into commit messages or code comments.

Maintaining Compartmentalization in Practice

Creating an anonymous account is just the first step. Long-term compartmentalization requires ongoing discipline:

Workspace Isolation

Create a dedicated directory structure for anonymous work that’s completely separate from your professional projects:

# Recommended directory structure
~/anonymous-work/
  ├── repos/
  │   ├── project-a/
  │   └── project-b/
  ├── ssh/
  │   └── github_anonymous/
  └── tor-session.sh

# Create the local git config for each repository
cd ~/anonymous-work/repos/project-a
git config user.name "your-pseudonym"
git config user.email "anon-email@provider.com"
git config core.sshCommand "ssh -i ~/.ssh/github_anonymous"

Browser Profile Management

Separate browser profiles prevent cookie leakage between identities:

# Firefox - Create separate profile for anonymous GitHub
firefox -ProfileManager

# Or directly launch with specific profile
firefox -P "anonymous-github" &

# Disable Firefox sync entirely - don't log into any Mozilla accounts
# Install Privacy Badger and uBlock Origin for tracking prevention
# Set Firefox preferences in about:config:
# privacy.trackingprotection.enabled = true
# privacy.trackingprotection.socialtracking.enabled = true
# network.IDN_show_punycode = true
# dom.event.clipboardevents.enabled = false

Git Configuration Verification

Before pushing any code, verify your git configuration:

# Verify local repository configuration
git config --local user.name
git config --local user.email
git config --local core.sshCommand

# Check commit history to ensure identity
git log -1 --pretty=format:"%an <%ae>"

# Verify SSH key being used
GIT_TRACE=1 git fetch 2>&1 | grep "SSHCommand\|IdentityFile"

Preventing Identity Leakage in Commit Content

Even well-configured commits can leak identity through commit messages or code content:

# BAD - Leaks employer name in commit message
git commit -m "Fixed issue reported by acme-corp customer"

# BAD - Leaks real email in author attribution
git commit --author="John Smith <john@realcompany.com>"

# GOOD - Generic, professional commit message
git commit -m "Improved error handling for edge case"

# Use pre-commit hooks to prevent accidents
cat > .git/hooks/pre-commit << 'EOF'
#!/bin/bash
# Verify no real names or emails in staged changes
STAGED=$(git diff --cached -p)
if echo "$STAGED" | grep -iE "(John|Smith|realcompany|employer)"; then
    echo "ERROR: Potential identity leak detected in staged changes"
    exit 1
fi
EOF
chmod +x .git/hooks/pre-commit

Understanding GitHub’s Privacy Limitations

Even with these precautions, be aware of GitHub’s data collection. GitHub knows your IP address when you connect, the timing of your activity, and may collect browser fingerprints. Using Tor consistently helps mitigate some of this, though some GitHub features may work less reliably.

GitHub’s rate limiting and CAPTCHA systems treat Tor users more strictly. If you encounter frequent blocks, consider using Tor bridges in pluggable transport mode:

# In Tor Browser settings, enable bridges:
# Tor Browser → Settings → Connection → Configure Proxy
# Use obfs4 or meek bridges provided by Tor Project

GitHub also tracks GitHub API usage by IP address. If you need to use the GitHub API through an anonymous account, route requests through Tor as well:

# Using GitHub API through Tor
import requests
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry

# Configure requests to use Tor SOCKS proxy
session = requests.Session()
proxies = {
    'http': 'socks5://127.0.0.1:9050',
    'https': 'socks5://127.0.0.1:9050',
}
session.proxies.update(proxies)

# Make GitHub API request
response = session.get(
    'https://api.github.com/user',
    headers={'Authorization': 'token YOUR_GITHUB_TOKEN'}
)

For projects requiring maximum anonymity, consider using GitHub alternatives:

GitLab.com offers public project anonymity without requiring phone verification. You can create an account with just an anonymous email address. GitLab’s infrastructure is also distributed, making account linkage harder.

Codeberg is built on Gitea and operated by a German non-profit. They explicitly support anonymous development and don’t track users across projects. No phone verification required.

SourceHut (sr.ht) offers subscription-based hosting with strong privacy controls. Source submission doesn’t require an account, reducing tracking across projects.

Each platform has different metadata collection and blocking characteristics. For maximum anonymity, use a different platform per project, rather than consolidating all anonymous work on a single GitHub account.

Built by theluckystrike — More at zovo.one