# tubeup turns a yt-dlp URL into an Internet Archive item > tubeup is a Python command line tool that downloads a video with yt-dlp and uploads it to the Internet Archive with its metadata attached. It is opinionated about its environment, needing ffmpeg, pipx and deno, and it refuses to be installed through Homebrew, MacPorts or apt. **bibanon/tubeup** — Use yt-dlp to download video/metadata and upload to the Internet Archive. - Repository: https://github.com/bibanon/tubeup - Website: https://pypi.python.org/pypi/tubeup/ - Stars: 521 · Forks: 74 - Language: Python - License: GPL-3.0 - Published: 2026-10-22 · Updated: 2026-10-22 · Language: en - Canonical page: https://hysenlabs.com/projects/bibanon-tubeup ## tubeup joins yt-dlp to the internetarchive module in one command The pipeline is short. yt-dlp handles the download, and it does so for YouTube or any other provider listed in its supported sites file. The python module internetarchive handles the upload and the metadata. tubeup is the layer that connects the two, so that a single URL becomes an Archive.org item with its metadata intact. It was designed by the Bibliotheca Anonoma project to archive single videos, playlists or whole accounts, and the README points out the warning that applies to anything beyond a single video. The packaging is a plain Python distribution: pyproject.toml declares the dependencies as internetarchive, docopt==0.6.2 and yt-dlp[default,curl-cffi], the version is read dynamically from the package attribute, and the console script is registered as tubeup, pointing at tubeup.__main__:main. That last detail matters, because the CLI is the interface, and the argument parsing is done by docopt with a version pinned to 0.6.2 rather than by argparse. ## ffmpeg, deno and pipx are not optional parts of the stack The recommended environment is a Linux VPS running Python 3.10 or higher, with pipx and deno installed, 2GB of RAM and 100GB of storage or more for anything beyond single short video mirroring. ffmpeg handles media work, curl is needed for the Deno install, and pipx isolates the Python packages. deno is the odd one out and deserves an explanation, because a JavaScript runtime sitting in a video archiver looks misplaced. The README states that Deno is installed for challenge solving, since external JavaScript support is required by the yt-dlp YouTube extractor. In other words, deno exists to let yt-dlp execute the JavaScript challenges that YouTube serves, and the installer is a curl pipe: ``` curl -fsSL https://deno.land/install.sh | sh ``` On Debian and Ubuntu the system packages are installed in one line, which also removes any yt-dlp that came from the distribution: ``` sudo apt remove yt-dlp ; sudo apt install ffmpeg python3-pipx curl ``` After that, pipx puts the tool on the path: ``` pipx ensurepath ``` ## Installation goes through pipx and refuses system package managers The README is unusually firm about one point: installation via third-party package managers such as Homebrew, MacPorts, or Linux system packages is not supported. The packages themselves are installed with pipx, which keeps yt-dlp, internetarchive and tubeup in separate isolated environments: ``` pipx install "yt-dlp[default,curl-cffi]" internetarchive tubeup ``` The yt-dlp extras matter. The default group is required by yt-dlp itself, and the README states that curl-cffi improves success for some extractors, which is a pragmatic way of saying that some providers behave better over a TLS stack that looks more like a browser. The next step is authentication against the Internet Archive. If you do not have an account, you need to register for one to give the script upload privileges, then configure the internetarchive client: ``` ia configure ``` That command prompts for the login credentials of the account you intend to upload under, and it is the step that turns the tool from a downloader into an archiver. Without it, nothing can be written to your item page. ## One URL in, one Archive.org item out Archiving starts with a URL and ends with an item page you can open in a browser: ``` tubeup ``` The URL can be anything yt-dlp supports, and for YouTube that includes account URLs and playlist URLs as well as a single video. Each archived video becomes its own Archive.org item, and the uploads of a given account can be inspected at the details page for that username. The rest of the flags adjust where files land and how chatty the run is. `--dir` sets a directory for downloads and metadata, `--output` passes a yt-dlp output template, `--proxy` routes the upload through a proxy, `--quiet` prints only errors and `--debug` prints all logs to stdout. Two flags deal with the archive itself: `--ignore-existing-item` skips the existence check on Archive.org, and `--use-download-archive` records the video URL in the download archive so that a repeated run only fetches videos that are not listed in that archive file. ## The metadata flag decides which open collection receives the item By default the uploaded video goes to the Community Video collection. Any other open collection can be chosen with the `--metadata` flag, which takes key:value pairs: ``` tubeup --metadata=collection:opensource_audio ``` Archive.org users can upload to four open collections, including Community Audio with the identifier `opensource_audio` and Community Software with its own identifier, and the README describes the collection identifiers in that same section. Beyond the collection, arbitrary metadata can be attached to the item, with a few exceptions that the README does not enumerate, and it links the Archive.org metadata schema documentation for the full list of fields. The CLI also accepts a cookies file and, for sites such as Nico Nico Douga, a username and a password pair. The metadata layer is where tubeup earns its keep compared with a bare yt-dlp call, because the Archive.org item is the durable artifact and its fields are what a future reader searches on. ## A 100GB disk and a POSIX host decide whether this fits your setup Several constraints come straight from the documentation, and they are the ones that rule tubeup out for some users. The platform requirement is a Linux or other POSIX system, preferably a VPS or a shell you control, and Windows support runs through WSL2 with Ubuntu and Windows Terminal. The resource requirement is 2GB of RAM and 100GB of storage, with the README noting that this is needed for anything other than single short video mirroring, and suggesting that an undersized OS drive be symlinked to something larger. Downloads are kept on disk during the run, so a large batch fills the volume before it uploads. The playlist and account modes come with the warning mentioned earlier. And the dependency stack is deep: ffmpeg, curl, pipx, deno, plus Python packages that are upgraded on their own schedule. On a machine where you cannot install a JavaScript runtime and a media toolchain, this is the wrong tool no matter how well the archiving logic fits. ## Upgrades come in two flavours, stable and nightly extractor Because the tool sits on top of yt-dlp, keeping it fresh is a two-part job. The routine step upgrades the Python packages and Deno together: ``` pipx upgrade-all ; deno upgrade ``` The README recommends running that periodically before use. For extractor breakage there is a second path, injecting a nightly yt-dlp build into the yt-dlp virtual environment using the latest nightly build tag, then upgrading so that the nightly build becomes the active version. The tagged releases follow a date-based scheme, with 2026.2.18 and 2026.2.19 released in February 2026 and 2026.5.8 in May 2026, and the last push to the repository was on 2026-08-12 with the repository not archived. Licensing is GPL-3.0-or-later, and the package metadata lists a Development Status of Production/Stable. A containerized option exists as well: the Dockerized version is provided by a separate project, etnguyen03/docker-tubeup, with its own instructions, which is the practical option when you cannot meet the POSIX requirement on the host. ## Conclusion Adopt tubeup if your job is to move videos from services yt-dlp supports into the Internet Archive, one URL at a time or as a batch, and if you can host a Linux box with the disk space to keep the downloads. Skip it for archival work that must run on Windows without WSL2, for anything that must be installed from a system package manager, or for large collections, where the storage and metadata overhead of one item per video becomes the bottleneck. Before your first run, confirm that `ia configure` succeeded and that `tubeup --version` matches the release you intend to depend on. ## FAQ ### What does tubeup do and which services does it work with? tubeup downloads a video with yt-dlp and uploads it to the Internet Archive with its metadata, using the internetarchive module. It works with any provider yt-dlp supports, and for YouTube that includes single videos, playlists and account URLs. ### How do I install tubeup? The README states that installation via third-party package managers such as Homebrew, MacPorts, or Linux system packages is not supported, so use pipx with `pipx install "yt-dlp[default,curl-cffi]" internetarchive tubeup`. You also need ffmpeg, curl, pipx and deno installed on a Linux or POSIX system running Python 3.10 or higher. ### Why does tubeup require deno? Deno is installed for challenge solving, because external JavaScript support is required by the yt-dlp YouTube extractor. Without a JavaScript runtime, the extractor cannot complete the challenges the site serves. ### How do I choose the Archive.org collection for an upload? By default the item goes to the Community Video collection, and the `--metadata` flag selects another one, for example `tubeup --metadata=collection:opensource_audio `. Arbitrary metadata fields can be added the same way, following the Archive.org metadata schema. ### How does tubeup avoid re-downloading videos it already archived? The `--use-download-archive` flag records the video URL in the download archive, so a later run downloads only videos not listed in that archive file and keeps recording the IDs of everything it fetched. ## Sources - [bibanon/tubeup on GitHub](https://github.com/bibanon/tubeup) - [License: GPL-3.0](https://github.com/bibanon/tubeup/blob/master/LICENSE) - [Project website](https://pypi.python.org/pypi/tubeup/) - [README](https://github.com/bibanon/tubeup/blob/master/README.md) - [Releases](https://github.com/bibanon/tubeup/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/bibanon-tubeup