How to spot a fake GitHub profile: checking a candidate's account, commit history and code
On this page
- Why do fake GitHub profiles exist?
- What can a GitHub profile prove, and what can't it?
- What does a fake or borrowed profile look like?
- How do you check a GitHub profile, step by step?
- How do you review a candidate's code safely?
- What is not a red flag?
- What should you do if the profile doesn't check out?
- GitHub profile check you can copy
- Questions people ask
A fake or borrowed GitHub profile usually fails one of three questions: does the candidate control the account, does the history show this person's work over time, and can they explain the code live. The profile page alone cannot answer them. GitHub's own documentation says the contribution graph places commits by the Git author date, which the author can set; that creating or forking a repository always counts as a contribution; and that commits are tied to an account by email address. So check what is hard to fake: account age, merged pull requests reviewed by other people's maintainers, an ownership test during the interview, and a live walkthrough of the code. As of November 2026.
This page is about the profile. Proving who wrote a specific take-home is in how to verify take-home assignment authorship, and the same checks for a professional networking profile are in how to verify a candidate's LinkedIn profile.
Why do fake GitHub profiles exist?
Mostly to make a resume look lived-in. Microsoft Threat Intelligence reported in June 2025 that North Korean remote IT workers "establish legitimacy through fake portfolios and profiles on developer platforms like GitHub and LinkedIn." The FBI's October 13, 2026 announcement adds that these workers falsely claim ownership of "professional profiles, and online identities belonging to others," and pay facilitators for accounts "which often contain years of legitimate activity history." Ordinary resume padding works the same way: a tutorial clone presented as a product, or a team project presented as a solo one. Many more candidates simply have thin public profiles for honest reasons, which is why the profile should never be the whole test.
What can a GitHub profile prove, and what can't it?
| Signal | What GitHub's documentation says | Weight |
|---|---|---|
| Contribution graph | "On your profile page, the author date is used to calculate when a commit was made," and creating a repository or forking one always counts (profile contributions reference) | Low: easy to pad |
| Commit author | Commits appear on a graph only if made with an email address connected to the account; you can see a commit's email by adding .patch to its URL (troubleshooting contributions) | Low to medium: Git lets anyone set the name and email |
| Verified badge | A commit or tag with a signature GitHub can verify is marked "Verified" (commit signature verification) | Medium: signed with the account's key, but not proof of who typed it |
| Account creation date | The public Get a user endpoint returns a created_at date for any account | Medium: a two-month-old account behind "ten years" of commits deserves a question |
| Merged pull requests to other people's projects | Search supports author: and is:merged qualifiers (searching pull requests) | Higher: a maintainer outside the candidate's control reviewed and accepted the work |
| Stars and followers | GitHub's Acceptable Use Policies ban "rank abuse, such as automated starring or following" and secondary markets for inauthentic activity | Low: they can be bought |
| Profile link on the resume | After a username change, "your old username becomes available for anyone else to claim," and links to the old profile return a 404 (username changes) | Check the link resolves to the person you think |
What does a fake or borrowed profile look like?
Each of these is a reason to ask a question, not proof of anything:
- A graph that is full but recent. The account was created months ago, yet the graph shows years of daily commits. That can happen honestly when someone pushes old local projects, so ask.
- Pinned repositories that are forks or tutorial clones with few or no commits of the candidate's own.
- Commit names and emails that don't match. Open a few commits with .patch. Several different author names, or emails at companies the candidate never mentions, suggest a shared or bought account.
- Distinctive code that also appears elsewhere. Search GitHub for an unusual line from a pinned project; an older copy under someone else's name is worth raising.
- A profile that does not match the resume. Different employer, different city, different stack, or a photo that does not match the person on camera. Microsoft's report describes AI tools used to place workers' faces into "more professional looking settings."
- No trail outside the account. No pull requests, issues or reviews in anyone else's repositories, despite claims of open source work.
How do you check a GitHub profile, step by step?
- Get the exact username from the candidate in writing. Look-alike usernames are easy to register; check the link on the resume opens the account the candidate means.
- Look at the account's basics. Open https://api.github.com/users/USERNAME in a browser and note created_at, the public repository count and the profile fields. Compare with the resume's dates.
- Open three commits in the pinned repositories and add .patch to each URL to see the author name and email. Note whether they match the candidate and each other.
- Search for merged pull requests elsewhere: is:pr is:merged author:USERNAME. Read one: who reviewed it, what they asked, how the candidate answered.
- Run an ownership test on the call. "Could you add the word 'heron' to your profile README while we talk? You can remove it right after." It takes a minute and shows the person on camera controls the account. Ask every candidate whose profile you rely on, not only the ones you doubt.
- Walk through the code. Have the candidate share their screen, open a repository they chose, explain one design decision and make a small change. How to run that well is in how to verify take-home assignment authorship; if you are not technical yourself, see interviewing for technical roles as a non-technical recruiter.
- Record facts. "Account created March 2019; two merged PRs to [project] reviewed by maintainers; README ownership test passed on [date]; walkthrough of [repo] by [interviewer]."
How do you review a candidate's code safely?
Read it in the browser; do not clone and run an unknown repository on a work laptop. A September 18, 2026 joint advisory by Japanese, U.S., Australian and German agencies describes North Korean actors hiding malware in code repositories and packages, including a Visual Studio Code project file "that triggers auto-run code execution when the folder is opened and trusted." That campaign targets job seekers through fake recruiters, but the lesson applies both ways. If code has to run, run it in an isolated environment your security team provides, and never mark an unfamiliar folder as trusted in your editor.
Candidates are targets too: the same advisory says these actors pose as employers and have "used recruiting services." Tell candidates you will never ask them to download and run code from an unfamiliar repository, and see recruitment scams impersonating your company.
What is not a red flag?
- An empty or sparse graph. Most professional code is private. GitHub's reference says that when someone publicizes private contributions, others see only "the number of contributions you made each day," with no details, and many people never turn that on.
- No GitHub at all. Plenty of strong engineers do not keep a public profile. Do not make one a requirement unless the job genuinely involves public open source work.
- A new account or a changed username. People start fresh after a job change or separate work and personal accounts.
- Account age as a proxy for anything personal. A long history says nothing about the candidate's age, and you should not try to infer it.
Hold every candidate to the same check at the same stage, and do not treat a name, accent or location as a signal; the FBI warns that aggressive controls produce false positives that "filter out qualified applicants."
What should you do if the profile doesn't check out?
- Ask neutrally. "The commits in this repository are under a different name. Can you tell me about that?" Shared team accounts, old employers' email addresses and a second personal account are all ordinary answers.
- Weigh it with everything else. A failed ownership test or a walkthrough the candidate cannot do matters far more than a thin graph. Resume-level checks are in resume fraud red flags.
- If the account belongs to someone else, the real owner may be a victim. GitHub lets you report a user from their profile through "Block or Report" (reporting abuse).
- If it looks organized (the same repositories behind several applicants, or profile ownership claims tied to a remote role with access to code), follow North Korean IT worker red flags and report to the FBI at ic3.gov. For security roles, see candidate fraud in cybersecurity hiring.
GitHub profile check you can copy
Candidate: ____________ Role: ____________ Checked by: ______
GitHub username (confirmed in writing): ____________
[ ] Resume link opens this account
[ ] Account created (created_at): ______ matches resume timeline? Y / N
[ ] 3 commits opened with .patch: author names/emails consistent? Y / N
[ ] Merged PRs to others' projects (is:pr is:merged author:USERNAME): __
[ ] Ownership test on live call (README word or gist), date: ______
[ ] Code walkthrough with a small live change, by: ______
[ ] Code reviewed in browser only (nothing cloned or run locally)
Outcome (facts only): ___________________________________________
GitHub documentation, Microsoft, FBI and joint advisory sources checked as of November 2026.
Questions people ask
Can a GitHub contribution graph be faked?
Yes, it can be padded. GitHub's documentation says the profile graph uses the Git author date to place a commit, and Git lets the author set that date, so years of activity can be created in an afternoon. Creating a repository and forking one always count as contributions. Treat the graph as decoration and look at merged pull requests, account age and a live walkthrough instead.
How can I tell if a candidate actually owns the GitHub account they listed?
Ask them, during a live call, to make a small change you specify, such as adding a word you choose to their profile README or creating a public gist with it, and then remove it afterward. That shows the person on the call controls the account. It does not show they wrote the code, which a walkthrough of the code tests.
Is a GitHub Verified commit badge proof that the candidate wrote the code?
No. GitHub marks a commit Verified when it carries a signature GitHub can verify, which shows it was signed with a key tied to the account. It is stronger than an unsigned commit, but it says nothing about who was at the keyboard or whether the code was copied.
Is it a red flag if a developer has no GitHub activity?
No. Much professional code lives in private company repositories, which show on a profile only as anonymous daily counts if the person chooses to share them, and many developers never use a public profile. Judge the candidate on the work you can test, not on a green graph.