# MoneyPrinterTurbo API Endpoints: Complete FastAPI Reference Guide

> Explore MoneyPrinterTurbo's 14 FastAPI API endpoints for automated video generation. This reference guide details endpoints for task orchestration, media management, and LLM content creation.

- Repository: [Harry/MoneyPrinterTurbo](https://github.com/harry0703/MoneyPrinterTurbo)
- Tags: api-reference
- Published: 2026-03-23

---

**MoneyPrinterTurbo exposes 14 REST API endpoints via FastAPI for automated video generation, task orchestration, media asset management, and LLM-powered content creation, all defined in [`app/controllers/v1/video.py`](https://github.com/harry0703/MoneyPrinterTurbo/blob/main/app/controllers/v1/video.py) and [`app/controllers/v1/llm.py`](https://github.com/harry0703/MoneyPrinterTurbo/blob/main/app/controllers/v1/llm.py).**

MoneyPrinterTurbo is an open-source automated video generation service that provides a programmable interface for creating short-form content. The API is built on FastAPI and organizes routes under versioned controllers, allowing developers to generate videos, manage background music, and automate scriptwriting through HTTP requests.

## API Architecture and Routing Structure

The application mounts all public routes through a root router defined in [`app/router.py`](https://github.com/harry0703/MoneyPrinterTurbo/blob/main/app/router.py). This router aggregates versioned sub-routers from the `app/controllers/v1/` directory, specifically separating video processing logic from LLM operations.

The endpoint surface is divided into three logical layers:

- **Core Video Pipeline**: Endpoints for full video generation, subtitle creation, and audio synthesis
- **Task and Asset Management**: CRUD operations for tasks and local media file handling
- **Content Generation**: LLM-powered endpoints for script and keyword generation

All endpoints return JSON responses following the schema models defined in [`app/models/schema.py`](https://github.com/harry0703/MoneyPrinterTurbo/blob/main/app/models/schema.py), with the exception of the streaming and download endpoints which return binary content.

## Video Generation Pipeline Endpoints

The video controller in [`app/controllers/v1/video.py`](https://github.com/harry0703/MoneyPrinterTurbo/blob/main/app/controllers/v1/video.py) implements three primary creation endpoints that handle different stages of the production pipeline.

**`POST /videos`** creates a complete short video through the full automation pipeline. Located at line 56 in [`app/controllers/v1/video.py`](https://github.com/harry0703/MoneyPrinterTurbo/blob/main/app/controllers/v1/video.py), this endpoint accepts parameters including `video_subject`, `video_aspect`, `voice_name`, and `bgm_type`, returning a task ID for asynchronous tracking.

**`POST /subtitle`** generates subtitle files independently without video rendering. Implemented at line 63, this endpoint processes a script and returns subtitle timing data.

**`POST /audio`** synthesizes speech audio from a provided script using the configured text-to-speech provider. This endpoint is defined at line 70.

## Task Lifecycle Management

The API provides comprehensive task monitoring and cleanup capabilities through the following endpoints in [`app/controllers/v1/video.py`](https://github.com/harry0703/MoneyPrinterTurbo/blob/main/app/controllers/v1/video.py):

- **`GET /tasks`** (line 101): Retrieves a paginated list of all video generation tasks. Accepts `page` and `page_size` query parameters.
- **`GET /tasks/{task_id}`** (line 116): Returns the current status, progress, and output URLs for a specific task UUID.
- **`DELETE /tasks/{task_id}`** (line 161): Removes a task record and deletes associated generated files from storage.

## Media Asset Management

MoneyPrinterTurbo maintains local repositories for background music and video materials, exposed through these endpoints:

**Background Music (`/musics`)**:
- **`GET /musics`** (line 84): Lists all available `.mp3` files in the local BGM directory
- **`POST /musics`** (line 104): Uploads a new background music file with multipart/form-data encoding

**Video Materials (`/video_materials`)**:
- **`GET /video_materials`** (line 27): Lists local video and image assets available for composition
- **`POST /video_materials`** (line 49): Uploads media files with support for `mp4`, `mov`, `avi`, `flv`, `mkv`, `jpg`, `jpeg`, and `png` formats

## LLM Content Generation Endpoints

The LLM controller in [`app/controllers/v1/llm.py`](https://github.com/harry0703/MoneyPrinterTurbo/blob/main/app/controllers/v1/llm.py) provides endpoints for automated content creation using large language models:

- **`POST /scripts`** (line 18): Generates a video script from a specified subject. Accepts `video_subject`, `video_language`, and `paragraph_number` parameters.
- **`POST /terms`** (line 33): Extracts visual search terms and keywords from a provided script to facilitate media asset retrieval.

## File Delivery and Streaming

For retrieving completed content, the API offers two delivery mechanisms defined in [`app/controllers/v1/video.py`](https://github.com/harry0703/MoneyPrinterTurbo/blob/main/app/controllers/v1/video.py):

**`GET /stream/{file_path:path}`** (line 73): Streams video files with HTTP range request support, enabling partial content delivery for large files and adaptive playback.

**`GET /download/{file_path:path}`** (line 84): Returns generated files as downloadable attachments using the `Content-Disposition` header.

## Practical API Usage Examples

### Health Check Endpoint

Verify service availability using the simple ping endpoint defined in [`app/controllers/ping.py`](https://github.com/harry0703/MoneyPrinterTurbo/blob/main/app/controllers/ping.py):

```bash
curl -X GET http://localhost:8000/ping

```

```python
import requests
response = requests.get("http://localhost:8000/ping")
print(response.text)  # Output: "pong"

```

### Creating a Full Video

Submit a video generation task to the `POST /videos` endpoint:

```bash
curl -X POST http://localhost:8000/videos \
     -H "Content-Type: application/json" \
     -d '{
           "video_subject": "春天的花海",
           "video_aspect": "portrait",
           "voice_name": "zh-CN-XiaoxiaoNeural-Female",
           "bgm_type": "random"
         }'

```

```python
import requests

payload = {
    "video_subject": "春天的花海",
    "video_aspect": "portrait",
    "voice_name": "zh-CN-XiaoxiaoNeural-Female",
    "bgm_type": "random"
}

response = requests.post("http://localhost:8000/videos", json=payload)
print(response.json())

# {"status":200,"message":"success","data":{"task_id":"<uuid>"}}

```

### Monitoring Task Status

Poll the task status endpoint to track progress:

```bash
curl -X GET "http://localhost:8000/tasks/<task_id>"

```

```python
task_id = "6c85c8cc-a77a-42b9-bc30-947815aa0558"
response = requests.get(f"http://localhost:8000/tasks/{task_id}")
print(response.json())

```

### Downloading Generated Files

Retrieve completed videos using the download endpoint:

```bash
curl -OJ "http://localhost:8000/download/6c85c8cc-a77a-42b9-bc30-947815aa0558/final-1.mp4"

```

```python
download_url = f"http://localhost:8000/download/{task_id}/final-1.mp4"

with requests.get(download_url, stream=True) as r:
    r.raise_for_status()
    with open("final-1.mp4", "wb") as f:
        for chunk in r.iter_content(chunk_size=8192):
            f.write(chunk)

```

### Generating Scripts via LLM

Create video scripts programmatically:

```bash
curl -X POST http://localhost:8000/scripts \
     -H "Content-Type: application/json" \
     -d '{"video_subject":"春天的花海","video_language":"zh","paragraph_number":1}'

```

```python
payload = {
    "video_subject": "春天的花海",
    "video_language": "zh",
    "paragraph_number": 1
}
response = requests.post("http://localhost:8000/scripts", json=payload)
print(response.json()["data"]["video_script"])

```

### Uploading Background Music

Add custom BGM files to the local library:

```bash
curl -X POST http://localhost:8000/musics \
     -F "file=@/path/to/track.mp3"

```

```python
files = {"file": open("/path/to/track.mp3", "rb")}
response = requests.post("http://localhost:8000/musics", files=files)
print(response.json())

```

## Core Implementation Files

The following source files define the MoneyPrinterTurbo API surface:

- **[`app/router.py`](https://github.com/harry0703/MoneyPrinterTurbo/blob/main/app/router.py)**: Root router that aggregates versioned sub-routers (`video`, `llm`)
- **[`app/controllers/v1/video.py`](https://github.com/harry0703/MoneyPrinterTurbo/blob/main/app/controllers/v1/video.py)**: Implements video generation, task CRUD, media upload/listing, and file streaming (lines 27-161)
- **[`app/controllers/v1/llm.py`](https://github.com/harry0703/MoneyPrinterTurbo/blob/main/app/controllers/v1/llm.py)**: Contains script generation and term extraction endpoints (lines 18-33)
- **[`app/controllers/ping.py`](https://github.com/harry0703/MoneyPrinterTurbo/blob/main/app/controllers/ping.py)**: Health check implementation returning `"pong"`
- **[`app/models/schema.py`](https://github.com/harry0703/MoneyPrinterTurbo/blob/main/app/models/schema.py)**: Pydantic models defining request/response validation schemas
- **[`app/asgi.py`](https://github.com/harry0703/MoneyPrinterTurbo/blob/main/app/asgi.py)**: FastAPI application factory with CORS configuration and static file mounts

## Summary

- **MoneyPrinterTurbo provides 14 distinct API endpoints** covering video generation, task management, media handling, and LLM content creation.
- **The API follows REST conventions** with standardized HTTP methods: `POST` for creation, `GET` for retrieval, and `DELETE` for cleanup.
- **Video generation is asynchronous**: The `POST /videos` endpoint returns a task ID that must be polled via `GET /tasks/{task_id}`.
- **File delivery supports both streaming and download** via dedicated endpoints with HTTP range support.
- **Media uploads are restricted to specific formats**: Videos (mp4, mov, avi, flv, mkv) and images (jpg, jpeg, png) for materials, mp3 for music.
- **All business logic is centralized** in [`app/controllers/v1/video.py`](https://github.com/harry0703/MoneyPrinterTurbo/blob/main/app/controllers/v1/video.py) and [`app/controllers/v1/llm.py`](https://github.com/harry0703/MoneyPrinterTurbo/blob/main/app/controllers/v1/llm.py) according to the FastAPI router pattern.

## Frequently Asked Questions

### What is the base URL for MoneyPrinterTurbo API endpoints?

By default, the FastAPI server runs on `http://localhost:8000` when started locally. All endpoints documented here are mounted relative to this base URL. The application also serves static files under `/tasks` (for completed outputs) and `/` (for the web UI) via the ASGI configuration in [`app/asgi.py`](https://github.com/harry0703/MoneyPrinterTurbo/blob/main/app/asgi.py), though these paths are not part of the programmatic API contract.

### How do I check the status of a video generation task?

Use the `GET /tasks/{task_id}` endpoint, where `task_id` is the UUID returned by the initial `POST /videos` request. This endpoint, implemented at line 116 of [`app/controllers/v1/video.py`](https://github.com/harry0703/MoneyPrinterTurbo/blob/main/app/controllers/v1/video.py), returns the current processing state, progress percentage, and URLs to the final files once generation completes.

### What file formats are supported for video material uploads?

The `POST /video_materials` endpoint accepts video files in `mp4`, `mov`, `avi`, `flv`, and `mkv` formats, as well as static images in `jpg`, `jpeg`, and `png` formats. For background music uploads via `POST /musics`, only `.mp3` files are supported according to the controller logic in [`app/controllers/v1/video.py`](https://github.com/harry0703/MoneyPrinterTurbo/blob/main/app/controllers/v1/video.py).

### Does MoneyPrinterTurbo support partial content streaming for large videos?

Yes. The `GET /stream/{file_path:path}` endpoint supports HTTP range requests, allowing clients to request specific byte ranges of large video files. This enables adaptive bitrate streaming and resume capabilities for downloads. For standard file retrieval without streaming, use the `GET /download/{file_path:path}` endpoint which returns the file as an attachment.