# You-Get's default branch is develop, its newest release predates its last commit by twenty months, and its metadata is a JSON file

> A read of soimort/you-get: why cloning the repository gives you the branch the readme calls unstable, what the itag listing does to stream selection, why a single runtime dependency is dukpy, and what a bare except in setup.py means for the package long description.

**soimort/you-get** — :arrow_double_down: Dumb downloader that scrapes the web

- Repository: https://github.com/soimort/you-get
- Website: https://you-get.org/
- Stars: 56,870 · Forks: 9,687
- Language: Python
- License: NOASSERTION
- Published: 2026-08-17 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/soimort-you-get

## The default branch is the one the readme calls unstable

The repository's default branch is develop. The installation section draws the distinction itself: the archive it calls stable is master, described as identical with the latest release on PyPI, while develop is described as carrying more hotfixes and unstable features.

That ordering has a consequence for the documented developer path, which is a clone.

```bash
git clone git://github.com/soimort/you-get.git
```

The readme calls this the recommended way for all developers, even those who do not often code in Python, and a clone takes the default branch, which is develop. The follow-up advice is to put the cloned directory on your PATH or install it from that path, so the recommended setup is also the one that gives you the unstable branch, and the difference between the two is only visible if you notice it. The zip route is the one where the choice is explicit, since it points at master.zip and develop.zip as separate downloads.

The readme also documents the opposite operation later on, upgrading a pip install to the development branch, which replaces the installed version in place.

```bash
pip install --upgrade --force-reinstall git+https://github.com/soimort/you-get@develop
```

Running that and then following a bug report opened against a release tag is a common way to end up debugging a different codebase than the one in the issue.

## The newest release is v0.4.1743 from 2025-01-04, and the last commit is 2026-08-24

Two dates in this repository are far apart. The three most recent releases are v0.4.1743 on 2025-01-04, v0.4.1730 on 2024-08-19 and v0.4.1718 on 2024-07-14. The last push to the repository landed on 2026-08-24, and the project is not archived. So roughly twenty months of commits exist with no corresponding PyPI release, and the normal upgrade command cannot reach any of them.

```bash
pip install --upgrade you-get
```

That command moves you between published versions, and the newest published version is from January 2025. There is a second documented route, which is the tool downloading its own source archive.

```bash
you-get https://github.com/soimort/you-get/archive/master.zip
```

The readme frames that as a way to get the latest release, which is another way of saying the archive is the artefact and the release is the tag on it. For anyone filing a bug, the practical question is which of the two trees a fix landed in, and the version string alone does not answer it: the pipenv example in the readme prints `you-get: version 0.4.1555`, an older number than any current release, because that snippet was written when the version was 0.4.1555.

## One runtime dependency, dukpy, and an optional socks extra for proxies

The dependency story is unusually small. requirements.txt carries a single comment and a single entry, labelled as a runtime dependency.

```bash
dukpy
```

The same single package appears in the setup script as the whole of install_requires, and the only extra defined is a socks extra pulling in PySocks. dukpy is a JavaScript interpreter for Python, which matters here because the tool scrapes pages: when a site's media URL is only produced by running its JavaScript, an embedded interpreter is the declared way to do that, and no browser is involved. The readme makes the same point in its motivation list, where avoiding proprietary JavaScript and Flash is given as a reason to use the tool at all.

Two limits follow. A page that requires execution to reveal its media will fail on a site the scraper has not been taught to parse, and the failure is a missing stream rather than a message explaining it. And proxy support is not on by default: someone behind a SOCKS proxy has to install the extra deliberately, and the readme does not say which environment variable points the scraper at it.

## The info listing decides your quality by order, and subtitles arrive unasked

The listing option is what makes the tool usable, and its output is where the decisions are made.

```bash
you-get -i 'https://www.youtube.com/watch?v=jNQXAC9IVRw'
```

Each stream carries an itag, a container, a quality label and a size, and each entry is followed by a comment showing the exact command that would fetch that one stream. The readme then states the rule that trips people up: by default, the one on the top is the one you get. So resolution and codec are chosen by list order rather than by any preference, and the top entry in the readme's own example is a webm at 320x240, not an mp4. Anyone who wants a specific format has to read the itag and pass it.

The other thing the output reveals is what you get besides the video. The sample run ends by saving a SubRip subtitle file alongside the media, named with the language code, and the readme confirms that closed captions are downloaded together with the video file. For a tool people use to archive material, that is a feature rather than noise, and it does mean an archive directory accumulates subtitle files you did not ask to keep.

## setup.py reads a JSON file for its metadata and hides a missing README

The packaging is unusual in a way worth knowing before you build anything. There is no metadata block written out by hand: the setup script sets a project name and a package name, then reads `you-get.json` for the name, author, author email, url, licence, description, keywords, classifiers and the console script entry points. The version is not read as text at all. It imports `src/you_get/version.py` with a source file loader and executes it, so the version is whatever that module evaluates to at build time.

That arrangement has one silent failure. The README is opened inside a bare except clause, and if the open fails the variable is set to an empty string, which is then passed as the long description. Nothing is printed and the build continues.

```python
except:
    README = ""
```

The readme documents the reason that file can be missing, since two Makefile targets regenerate `README.rst` from `README.md` with pandoc, and pandoc is not a Python dependency. A build run without pandoc on a clean tree produces a package with no long description and no error message. Everything else the script sets is conservative and dated, with packages discovered under `src`, a test suite pointed at `tests`, `zip_safe` and `include_package_data` both enabled, and platforms declared as any.

## make clean opens a dialog box, and make release only echoes the command

The Makefile is short enough to read in full, and two of its targets describe how the project actually gets built and published. Tests run through the standard library rather than a third party runner, discovering tests from the parent directory while inside `src`.

```bash
(cd src; python -m unittest discover -s ../tests)
```

Publishing is not automated. The release target depends on build, prints the upload instruction, and stops.

```bash
twine upload --sign dist/you_get-VERSION*
```

Cleaning is where a contributor loses time. The target opens a confirmation dialog through zenity before it deletes anything, so on a headless Linux box, on macOS, or inside a container where zenity is not installed, `make clean` fails on its first line and removes nothing. The other two conveniences need pandoc, one target generating HTML from the readme and another generating the reStructuredText file that the packaging script reads as its long description.

For a contributor the practical list is short: `make test` for the suite, `make i` for an interactive Python session with the package already imported and its version printed, and `make build` to produce the artefacts. A `.PHONY` declaration covers the targets, so a stray file named `test` in the tree will not shadow the suite.

## Seven install routes, and none of them installs FFmpeg for you

The installation section offers seven options and the prerequisites sit above all of them: Python 3.7.4 or above, FFmpeg 1.0 or above, and RTMPDump as an optional extra for sites that still need it. FFmpeg is the one that catches people, because it is a native binary that no pip, brew or pkg invocation in this document installs. A user who follows option one and then finds that downloaded streams are not merged or converted has an FFmpeg problem, not a you-get problem, and the sample output in the readme shows a merged webm, which means the merge succeeded.

The seven routes differ in what they pin. `pip install you-get`, with the Python 3 version of pip, gives the published release. An antigen bundle line in `.zshrc` gives the zsh plugin from the repository. A zip from master or develop gives a directory to place on PATH, with `pipenv` offered for a virtual environment. A clone gives the default branch. `brew install you-get` is Mac only, `pkg install you-get` is FreeBSD only, and `flox install you-get` covers Mac, Linux and Windows WSL.

The floor of Python 3.7.4 is explained by a notice dated 30 May 2022 about support for 3.5, 3.6 and 3.7 eventually being dropped, which links to a wiki page on TLS 1.3 post-handshake authentication. A second notice, from 8 March 2019, points people with issues to CONTRIBUTING.md rather than the issues tab, which tells you where the project's own workflow lives now.

## Conclusion

You-Get still fits a single job well, saving a video or a page's media with one command and no browser, and the pip route is the one to use for a stable install. Check the itag listing rather than accepting the default stream, install FFmpeg yourself because nothing in the install path does it, and if you clone the repository remember you get develop, not the branch that matches PyPI. Before running any build or clean target, note that the Makefile calls zenity and pandoc, which are not Python dependencies.

## FAQ

### How do I install you-get?

The shortest route is `pip install you-get` with the Python 3 version of pip, and the prerequisites are Python 3.7.4 or above plus FFmpeg 1.0 or above, with RTMPDump optional. Cloning is the route the readme recommends for developers, and Homebrew, pkg, flox, antigen and a plain zip are the other five.

### What is you-get?

It is a small command line utility that downloads videos, audio and images from the web by scraping pages, and it can also stream an online video into a media player without a browser. It also handles arbitrary non-HTML content, in other words binary files.

### Is you-get legal to use?

The readme does not address legality, and it points at LICENSE.txt, SECURITY.md and a licence string in you-get.json instead. What it does give is a list of motivations, including downloading things for your own pleasure and not wanting proprietary JavaScript running on your computer.

## Sources

- [Official documentation](https://you-get.org/)
- [Official README](https://github.com/soimort/you-get#readme)
- [Project repository](https://github.com/soimort/you-get)
- [Release notes](https://github.com/soimort/you-get/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/soimort-you-get