# YTPro: a JavaScript-injected YouTube client for old Android phones > YTPro is an MIT-licensed Android app that loads YouTube in a WebView and injects JavaScript to add ad blocking, background audio, downloads and Gemini summaries. It is aimed at devices that no longer receive official YouTube updates, and its own README calls it an educational project. **prateek-chaubey/YTPro** — Youtube client with older Android version support, background player, Google Gemini ✨ and many more features. - Repository: https://github.com/prateek-chaubey/YTPro - Website: https://prateek.is-a.dev/YTPro - Stars: 2,667 · Forks: 219 - Language: JavaScript - License: MIT - Published: 2026-09-10 · Updated: 2026-09-10 · Language: en - Canonical page: https://hysenlabs.com/projects/prateek-chaubey-ytpro ## The problem YTPro targets: YouTube on hardware Google has moved past The official YouTube app raises its minimum Android version over time. Devices that still work fine as media players fall off that list, and the app either stops updating or refuses to install. YTPro approaches this differently: instead of reimplementing YouTube, it loads the mobile web interface inside an Android WebView and injects JavaScript into the page. The README describes the project as "an educational project aimed at showcasing javascript injection into a webview to enhance productivity", which is an unusually honest framing. The audience is people with older Android hardware, plus anyone who wants background audio, downloads or Sponsor Block style skipping without paying for Premium. It is not a general-purpose YouTube replacement for a current flagship phone, and the project does not claim to be one. ## How the WebView injection model works, and where it leaks The architectural bet is thin: the repository's primary language is JavaScript, and the top-level layout has an app/ module, Gradle build files, a scripts/ directory and a signer/ directory. The app hosts YouTube in a WebView, and the injected scripts modify the page. That is why features like hiding Shorts, forcing zoom, gesture control for volume and brightness, and blocking ads can ship without touching YouTube's private APIs. It also explains why the feature list is so long relative to the codebase: most of it is DOM manipulation. The same design produces predictable failure modes. When YouTube changes its markup, injected selectors break, and the app can regress without any dependency being updated. The release history reflects that. v3.95 was tagged "Fixed CSP issue and other minor bugs", which is exactly the class of bug you get when you inject script into a page whose Content Security Policy you do not control. v3.98 was tagged "Fixed Downloader and other minor bugs". A downloader that breaks and needs a release to repair is a maintenance treadmill, not a one-time build. The README credits Sponsor Block, return-youtube-dislike and YouTube.js. Two of those are external projects, which sits oddly beside the claim of "Almost 0 Internal Dependencies". Read that claim as being about bundled libraries rather than about the app's dependence on YouTube's page structure, which is total. ## Installing YTPro from the nightly build There is no Play Store listing in the README. The download section points at a nightly.link artifact produced by the project's Gradle GitHub Actions workflow, named YTPRO.zip. The README also states that the app supports auto updation, so once installed it can update itself rather than requiring a fresh sideload each time. The README gives this download link: ```text https://nightly.link/prateek-chaubey/YTPro/workflows/gradle/main/YTPRO.zip ``` Fetch that zip, extract the APK inside, and sideload it on the device. Because it is not distributed through a store, Android will require you to allow installation from the source you used. The repository also contains a signer/ directory and Gradle wrapper scripts, so building from source is possible if you prefer not to trust the artifact. The checked-in wrapper is gradlew on Linux and macOS and gradlew.bat on Windows, run against the settings.gradle and build.gradle at the repository root. The README does not document the resulting output path or a build command, so treat the nightly artifact as the supported path. For the Gemini features, the README documents prompt variables rather than a key setup step: ```text {url} the URL of the video {title} the title of the video {videoId} the video id of the video ``` Those placeholders go into a customisable prompt, and the README says both prompts and models are configurable. It does not document where the API key is entered, so expect to find that in the app's settings rather than in the README. ## What actually breaks: CSP, downloads and the update gap The honest limitations here are visible in the release notes rather than the feature list. Content Security Policy breakage is structural. YouTube can tighten CSP at any time, and when it does, injected script stops running and features silently disappear. There is no documented fallback for that case, and the README does not describe rollback. The downloader is the second weak point. It depends on the same page structure the rest of the injection depends on, and v3.98 exists because it broke. If downloading is your main reason for using YTPro, understand that you are relying on a component with a demonstrated history of breaking and being patched. Maintenance cadence is another consideration. The last push to the repository was on 2026-07-25. The most recent release is v3.98 from 2026-05-01, preceded by v3.95 on 2025-11-14 and v3.92 on 2025-10-25. That is a modest release rhythm with long gaps, which matters when the app's correctness depends on a third party's markup. The README's ToDo list still contains "Enhance Audio" and "Skip Silence", so those are known gaps rather than shipped features. Finally, the app is sideloaded and unsigned by any store process. Nothing in the README describes a signing key you can verify against. That is a trust decision, not a technical one. ## YTPro compared with yt-dlp front ends and patched YouTube clients The closest alternatives fall into two camps, and they differ from YTPro in approach rather than in feature count. A yt-dlp front end does not embed YouTube at all. It calls an extractor that resolves stream URLs and downloads them, then plays the result locally. That decouples playback from YouTube's page markup, so a markup change does not break the player. What you lose is the logged-in browsing experience: no feed, no recommendations, no in-app search against your account. YTPro keeps the real YouTube interface and accepts the fragility that comes with it. If your goal is archiving video, the yt-dlp route is more durable. If your goal is watching YouTube with ad blocking on an old phone, YTPro is the one that preserves the interface. Patched YouTube clients take a third route: they modify the official APK. Those give you near-native playback and a familiar UI, but they inherit the official app's minimum Android version, which defeats the point for the hardware YTPro is aimed at. YTPro's WebView approach is what lets it run on versions the official app has dropped. The trade is that you are watching a web page in a wrapper, not the native player, and the README's feature list (minimize video, picture in picture, background audio) is a set of workarounds for exactly that gap. ## Licence, upgrade cost and what MIT does not cover YTPro is MIT licensed, and the LICENSE file sits at the repository root. That is permissive: you can read the code, fork it, and redistribute it, provided the copyright notice and permission notice are retained. It does not grant you anything regarding YouTube's terms of service, and it does not cover the third-party projects the README credits. Sponsor Block, return-youtube-dislike and YouTube.js each carry their own licences, and if you fork YTPro you need to check those separately. Nothing here is legal advice; the point is simply that MIT on the wrapper does not resolve the status of what the wrapper talks to. Upgrade cost is the more practical concern. Because the app supports auto updation, staying current is cheap once installed. The cost is in the opposite direction: if a release regresses, you are debugging a sideloaded APK with no store-mediated rollback. Keeping the previous APK before updating is the only rollback mechanism the project's documentation implies, and the README does not document one. ## Conclusion YTPro is worth trying if you have an Android device that the official YouTube app has left behind and you accept a sideloaded APK built by a GitHub Actions workflow. It is the wrong choice if you need Play Store updates, a stable playback pipeline, or a client whose behaviour you can predict from documentation, because the README documents features rather than failure modes. Before installing, verify the nightly.link artifact actually corresponds to a commit you trust, and check whether the downloader works on your device, since v3.98 was released specifically to fix it. ## FAQ ### Is there a free YouTube app? YTPro is free and MIT licensed, and the README distributes it through a nightly.link artifact rather than a store. It is not an official YouTube app; the README describes it as an educational project demonstrating JavaScript injection into a WebView. ### What does the YouTube app do? YTPro loads YouTube in an Android WebView and injects JavaScript to add features such as ad blocking, background audio, downloads, dislike counts and Gemini video summaries. The README lists those capabilities and credits Sponsor Block, return-youtube-dislike and YouTube.js. ### How do I install the YTPro APK? Download YTPRO.zip from the nightly.link URL in the README, extract the APK, and sideload it. The README also states the app supports auto updation, so later versions can install themselves. ### Which Gemini variables can I use in a YTPro prompt? The README documents three: {url} for the video URL, {title} for its title and {videoId} for the video id. Prompts and models are described as customisable. ### Does YTPro work on current Android versions? The README frames the project around older Android version support, and the WebView approach is what allows that. It does not state a maximum supported version, so the README is silent on how it behaves on the newest releases. ## Sources - [License: MIT](https://github.com/prateek-chaubey/YTPro/blob/main/LICENSE) - [prateek-chaubey/YTPro on GitHub](https://github.com/prateek-chaubey/YTPro) - [Project website](https://prateek.is-a.dev/YTPro) - [README](https://github.com/prateek-chaubey/YTPro/blob/main/README.md) - [Releases](https://github.com/prateek-chaubey/YTPro/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/prateek-chaubey-ytpro