Open-source project
QasimWani/LeetHub avatar
QasimWani/LeetHub

LeetHub: the browser extension that commits your LeetCode solutions

Automatically sync your leetcode solutions to your github account - top 5 trending GitHub repository

4,361 stars1,493 forksJavaScriptMIT

At a glance

What is it?
LeetHub watches leetcode.com for a passing submission and pushes that code into a GitHub repository you bind to it. It removes the copy-and-paste chore from practice, and it inherits every fragility of a scraper bolted to somebody else's page.
Who is it for?
Adopt LeetHub if you solve problems almost daily and want an archive you never have to maintain by hand, and leave it alone if your portfolio is meant to read as deliberate, hand written work, or if you need filenames and commit structure you control. Its mechanism is a page watcher reacting to a passing submission, so the first thing to verify is a real end to end run in your own browser: solve one problem, open the bound repository, and confirm the commit arrived.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 146 days ago.
What is it written in?
Mainly JavaScript, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • QasimWani/LeetHub4,361 ★ · +9
Star history
Repository2026-09-232026-11-15
QasimWani/LeetHub4.4k4.4k

9 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The commit fires when LeetCode reports every test passing

LeetHub does one thing: when a submission on leetcode.com comes back green, that code is written into a file in a GitHub repository and a commit is made. The trigger is the pass state, not a button. Nobody names a filename, nobody picks a folder, and nobody opens a terminal. For a candidate who solves a handful of problems a day, that removes the only part of the habit with friction, which is the manual copy, the manual filename, and the manual git push after every attempt.

The audience is narrow and the project says so plainly. The README argues that recruiters look at GitHub contribution history and that "GitHub is developers' #1 portfolio". The author built it after receiving internship offers from Fortune 100 companies and wanted the practice record to exist without separate effort. Nobody is using this to teach algorithms; the solving still happens on LeetCode's site with its own editor and its own judge.

So the value is bookkeeping, and the tradeoff follows from the mechanism. The extension sits in the page, watches for a signal LeetHub does not own, and reacts. Anything LeetCode changes about that page is a direct threat to the sync, and nothing in the repository insulates you from it.

Authorize with GitHub, then bind one repository to the extension

First use is four clicks, in this order. Install LeetHub from the Chrome Web Store, or the Firefox add-on linked beside it. Launch it and click "authorize with GitHub", which sets up the link between the extension and your account without you handling a token. Then press "Get Started" and either create a fresh repository or point the extension at one you already own. Only after that do you go solve something. Progress is viewed by opening the extension again.

The repository is marked private by default at this step, which is a decision worth understanding rather than skipping. A new user sees the word "private" and moves on; the README's own argument about recruiter-facing portfolios never mentions changing it. See the section on private defaults below for why that gap matters.

Nothing in this flow needs Node, a build step, or a package install. The published artifact is the thing you load, so the only thing standing between you and a working sync is the OAuth grant and the repository binding.

The 400ms claim ships without the measurement behind it

The README heads a section with "THIS FAST (~400ms, 530x speed improvement)". Read closely and the figure has nothing to attach to: there is no before number, no description of what is being timed, no hardware, no browser version, and no statement of whether the 530x compares the extension against manual pushing or against an earlier version of itself. A speedup ratio that large normally means the old path was doing something tedious, and the extension does remove a manual copy-paste and push, so the direction is plausible. The magnitude is marketing copy.

That matters less for speed than for what it says about trust. If you are going to hand a browser extension a GitHub OAuth grant and let it write files, you should be able to find a measurement. Its absence is not evidence the tool is slow. It is evidence nobody wrote down what they were timing.

Every line of the page-watching logic is readable in the repository, which is the correct way to settle the question the marketing number leaves open.

The runtime dependency list is empty, and everything shipped is a file

An empty dependencies object is the right shape for an extension: manifest.json, popup.html, popup.js and welcome.html load as files, not as an npm bundle. Everything in devDependencies is contributor tooling rather than code that reaches your browser. Prettier and eslint sit there so a pull request does not arrive unformatted.

The README header advertises the project as a top 5 trending JavaScript repository, and that popularity attracts readers who expect a numbered product lineage. This tree has none. There is no major version to read a changelog against, no tagged release to diff, and no release note explaining what changed between two installs.

You get updates the way any Chrome Web Store extension gives them to you: unannounced, at the browser's convenience. That is fine for a tool that only writes your own solution files. It is a poor fit if you plan to pin a known-good version across several machines and want to reason about what changed underneath you.

Contributors load the folder unpacked and run npm run setup

To work on LeetHub rather than install it, the README gives a manual path: fork and clone the repository, open chrome://extensions, enable developer mode, click "Load unpacked", select the entire LeetHub folder, then install the developer dependencies.

That last step is a plain npm install driven by the setup script:

bash
npm run setup

What you should see afterwards is the toolchain from package.json, since dependencies and devDependencies hold only linting and formatting packages. The same scripts cover the rest of the contributor loop:

bash
npm run               Show list of commands available
npm run format        Auto-format JavaScript, HTML/CSS
npm run format-test   Test all code is formatted properly
npm run lint          Lint JavaScript
npm run lint-test     Test all code is linted properly

There is no build, no test suite and no CI target in that list. `format-test` and `lint-test` check style, and they are the only checks a contributor can run before opening a pull request.

Private by default contradicts the portfolio pitch in the README

The README argues that recruiters want to see open source contributions and that GitHub is the portfolio of record. The setup flow then creates the repository private by default. Both statements sit in the same document, and nothing bridges them: there is no line telling you to flip visibility, and no step in the four-step list about making the repo visible.

Left alone, the extension does exactly what it promises while producing an archive nobody but you can read. A user can run it for a year and still have nothing to point a hiring manager at, which is the outcome the README opens with. This is the sort of gap a skim misses, because both halves are individually reasonable.

It also marks the repository as a practice log rather than a project.

A manual git push is the real fallback when the page changes

LeetHub watches someone else's page for a state change and reacts automatically. The alternative approach is the one it replaces: solve the problem, copy the code out, name the file yourself, commit, push. That path is slower per problem and it does not forget anything. It is also completely under your control, immune to a LeetCode markup or API change, and produces filenames and commits you chose rather than ones a page scraper chose for you.

LeetHub's own advantage is narrow and measurable in effort: zero seconds of extra work per problem, which is exactly the claim the README makes when it argues there is no easy way to keep problems in one place. The cost is a dependency on an invisible coupling. The README does not document a rollback path, an export of previously synced files, or what happens to your repository when the extension stops committing.

If the extension stops committing, an unchanged repository is the failure mode to plan around, and the reason the manual path stays worth knowing.

Editorial conclusion

Adopt LeetHub if you solve problems almost daily and want an archive you never have to maintain by hand, and leave it alone if your portfolio is meant to read as deliberate, hand written work, or if you need filenames and commit structure you control. Its mechanism is a page watcher reacting to a passing submission, so the first thing to verify is a real end to end run in your own browser: solve one problem, open the bound repository, and confirm the commit arrived. The repository's last push was on 2026-06-22 and it carries no tagged release, so there is no known good version to fall back to if that first commit does not appear. Once it works, decide deliberately whether to switch the repository from its private default to public, since the README argues for a recruiter visible record and never tells you to do it.

Frequently asked questions

How does LeetHub work?

It is a browser extension that watches leetcode.com and pushes your code to GitHub when you pass all tests on a problem. You authorize it with GitHub once and bind it to an existing or new repository, which is private by default.

Is LeetHub legit?

It is a working, published project rather than a proof of concept: the code is readable in the repository and the extension is distributed through the Chrome Web Store and a Firefox add-on. Judge it on your own needs, since it writes only the problems you solve yourself.

Is LeetHub safe?

The extension asks for GitHub authorization before it writes anything, and all of its source is readable before you install it. It still receives write access to the repository you bind it to.

How do I use the LeetHub extension?

Install it from the Chrome Web Store or the Firefox add-on, launch it, click "authorize with GitHub", then press "Get Started" to set up a repository. After that you solve problems as usual and open the extension to view progress.

What is LeetHub?

It is a browser extension that automatically pushes your code to GitHub after you solve a LeetCode problem, so your solutions accumulate in a repository without manual commits. It is written in JavaScript and runs inside Chrome or Firefox.

Official sources

  1. Issues
  2. License: MIT
  3. Project website
  4. QasimWani/LeetHub on GitHub
  5. README
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/qasimwani-leethub.svg)](https://hysenlabs.com/projects/qasimwani-leethub)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/qasimwani-leethub.svg)](https://hysenlabs.com/projects/qasimwani-leethub)

Was this useful?