# moneyprinterturbo: a pinned pipeline whose README is a sponsor page

> harry0703/MoneyPrinterTurbo chains a language model, TTS providers, stock footage, subtitles and ffmpeg into a short video generator with a Streamlit WebUI on 8501 and a FastAPI service on 8080. Every dependency is pinned to an exact version, the front page is sponsor advertising rather than documentation, and the interesting engineering is in the files.

**harry0703/MoneyPrinterTurbo** — MoneyPrinterTurbo uses language models and an automated media pipeline to create short videos from a topic or keyword.

- Repository: https://github.com/harry0703/MoneyPrinterTurbo
- Stars: 126,642 · Forks: 19,774
- Language: Python
- License: MIT
- Published: 2026-08-08 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/harry0703-moneyprinterturbo

## Exact pins for twenty-two packages, plus a uv.lock on top

pyproject.toml is where the real specification lives, and its header explains the intent: main dependencies were consolidated into pyproject.toml, and uv.lock pins the runtime so different machines do not resolve different version combinations. Every entry is an exact pin, from moviepy 2.2.1 and streamlit 1.59.1 through fastapi 0.136.3, openai 2.24.0, faster-whisper 1.1.0, litellm 1.86.2 and google-genai 2.11.0, up to azure-cognitiveservices-speech 1.41.1 for speech and dashscope 1.20.14.

Two details are worth carrying into your own plan. The floor is Python 3.11 or newer, and audioop-lts is conditioned on Python 3.13 or later, so the interpreter version changes the dependency set. And requirements.txt still exists with the comment that it keeps legacy pip install support while the primary dependencies moved elsewhere. Consequence: `pip install -r requirements.txt` is not the same resolution as the lockfile, so pick one path and stay on it.

## The front page sells API credits, and the pipeline spends them

The promise is one input and one video: give it a topic or a keyword and it produces a script, matches footage, generates subtitles and background music, and composites a short video. What the front page does not do is explain any of that. Its body is a table of sponsors, each with a referral link: Kimi from Moonshot AI, APIMart, Metaso for MiniMax video, Infistar.cc, OfoxAI, UCloud AstraFlow, Fluxion AI, plus a user discount on Kimi credits running to the end of 2026.

The sponsor list is also a map of what the pipeline calls. The text credits Kimi with writing the script, distilling footage search keywords and deciding the final shots, and names Seedance, MiniMax H3 and Wan for video, GPT Image 2.5 and Seedream for cover images. Consequence: a render is a series of metered API calls, not a local computation, so the cost of a run is set by your provider and the front page's free framing is not a cost estimate.

## Two services, two ports, both bound to loopback

docker-compose.yml declares exactly two services and they are different programs. The webui service runs Streamlit against webui/Main.py on port 8501, and the api service runs python3 main.py on 8080. Both are published to 127.0.0.1 on the host, and both mount the repository over /MoneyPrinterTurbo so your code is live inside the container.

```yaml
    ports:
      - "127.0.0.1:8501:8501"
    command: [ "streamlit", "run", "./webui/Main.py", "--server.address=0.0.0.0", "--server.port=8501" ]
```

The Streamlit command is spelled out in full, with CORS enabled, usage stats off and the email prompt hidden. Consequence: out of the box nothing is reachable from another machine, because the loopback binding is deliberate, and moving it is a change to the compose file rather than a setting in the interface. There is also no service definition for Redis even though redis 5.2.0 is a pinned runtime dependency, so bring your own or find out what the code does without it.

## The image defaults to a China mirror, and it retries apt three times

The Dockerfile starts from python:3.11-slim-bullseye, sets the working directory, grants it mode 777 and points PYTHONPATH at it. Two build arguments decide the network behaviour: DOCKER_BUILD_MIRROR defaults to china and PIP_USE_OFFICIAL defaults to 0. A comment explains why the mirror flips when the GitHub Actions job publishes to GHCR, so overseas runners do not stall on a slow mirror.

The system dependencies are two packages:

```bash
apt-get update
apt-get install -y --no-install-recommends git ffmpeg
```

They are installed inside shell functions with a three attempt retry and a five second wait, and the comment above them records the bug that shape fixed: an old loop ended in a sleep that always returned 0, so an image could be built successfully with git and ffmpeg missing. Consequence: build outside China without overriding the mirror argument and you will wait a long time for apt sources you do not need.

## A separate GPU image, a separate release compose, a separate claude image

The root carries four Dockerfiles and four compose files: Dockerfile, Dockerfile.gpu and Dockerfile.claude, alongside docker-compose.yml, docker-compose.gpu.yml, docker-compose.claude.yml and docker-compose.release.yml. There is also webui.sh and webui.bat for running the WebUI without a container, a cli.py, main.py, an app/ package, a docs/ directory and a resource/ directory, with a .python-version file pinning the interpreter.

Nothing in the manifest tells you which combination is meant for production; the names imply the split without defining it. Consequence: if you are sizing a machine, the default compose gives you the slim CPU image and no video model locally at all, and the GPU path is a different file you have to read before you start. The Claude-branded image and compose pair are equally undefined in what you have, so treat them as experimental rather than as the reference deployment.

## Coverage counts the CLI and the WebUI as production entry points

The test configuration is unusually opinionated and worth reading before you trust a green run. Branch coverage is enabled, the measured sources are app, cli, webui, main and docs/skill, and the floor is 70 percent, with the file recording that measured branch coverage on Python 3.11 and 3.13 both exceeded 70.4 percent. The stated reasons are specific: branch coverage catches the case where a line ran but the other side of the condition never did, and the CLI and WebUI are counted alongside the service layer because they are production entry points, not samples.

The same reasoning names the tests that justify the floor: failure states, async publish recovery and Redis atomic updates. The dev group is pinned too, with pytest 9.1.1, coverage 7.15.1 and ruff 0.15.21. Consequence: the project tells you which parts it considers load bearing, and a change to the Redis path is supposed to break a test rather than pass silently.

## webui/Main.py is exempt from one lint rule because of sys.path

The ruff configuration carries a single per-file exemption, and the comment above it gives the reason in plain terms: the WebUI has to add the project root to sys.path before it can import the app package, so webui/Main.py is excluded from E402, the rule against module level imports that are not at the top of the file.

That tells you how the code is actually run. pyproject.toml has a hatchling build system and could be installed as a package, but the WebUI is written to reach into the source tree instead, and the compose file reinforces it by bind-mounting the repository. Consequence: editing files under app/ changes behaviour without any install step, which is convenient in development and means your running system is whatever is on disk, not a versioned artifact.

## config.example.toml is the only configuration file you get

The repository ships one configuration file, config.example.toml, and no config.toml. That naming is the whole onboarding story: the tool reads a file you have to create, and the example is the only description of the keys available, since the front page does not document them.

Add to that the credential surface. The pipeline talks to speech providers through edge-tts, dashscope and azure-cognitiveservices-speech, and to language and media models through litellm, openai and google-genai, with Redis present for state. An optional TwelveLabs extra exists for video understanding, installed with `uv sync --extra twelvelabs` and only needed when twelvelabs_api_keys is set. Consequence: expect to spend the first session reading that example file and deciding which providers you are willing to be billed by, because nothing runs without those keys.

## Conclusion

Use MoneyPrinterTurbo if you want a full short video pipeline you can read end to end in Python and are willing to supply model API keys and pay per render. Do not pick it expecting a finished product: the configuration is a TOML file you have to write yourself, the front page documents nothing, and each render calls paid services. Verify three things first, the Python 3.11 floor, whether you have a Redis instance for the atomic update path, and what your TTS and model providers cost per run.

## FAQ

### How do I install moneyprinterturbo?

pyproject.toml requires Python 3.11 or newer, and dependencies are pinned there and in uv.lock, with requirements.txt kept only for legacy pip installs. The repository ships webui.sh and webui.bat launchers, config.example.toml, a Dockerfile and four compose files, while the README front page is a sponsor section rather than install instructions.

### What does moneyprinterturbo need to run a render?

The Docker image installs git and ffmpeg on top of python:3.11-slim-bullseye. The pipeline itself calls out to language model, text to speech and media providers through litellm, openai, google-genai, dashscope and azure-cognitiveservices-speech, so API keys and a paid account are part of the setup.

### Does moneyprinterturbo have a web interface and an API?

Yes, and they are separate services in docker-compose.yml. The WebUI runs Streamlit against webui/Main.py on port 8501, and the API runs python3 main.py on port 8080, with both published on 127.0.0.1 only.

### Why is the moneyprinterturbo README mostly sponsor links?

The front page is a sponsor table for API providers, each with a referral link, including a user discount on Kimi credits valid to the end of 2026. Technical detail sits in the repository files instead, so read pyproject.toml, docker-compose.yml and config.example.toml instead of the README.

## Sources

- [Official README](https://github.com/harry0703/MoneyPrinterTurbo#readme)
- [Project repository](https://github.com/harry0703/MoneyPrinterTurbo)
- [Release notes](https://github.com/harry0703/MoneyPrinterTurbo/releases)

---

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