Planning an AI short-drama pipeline without buying a new GPU

Before buying more hardware for AI video, compare the cost of upgrading with renting for the stages that need a GPU. Our ep05 explainer discusses that decision (video link below); this article proposes a workflow, not a completed production benchmark.

If you would rather defer a hardware purchase, one possible setup is to run the light stages through an API and rent a GPU for the stages that need your own model weights.

Untested example: The snippets below were checked against public documentation, not executed. They are illustrative, not a tested end-to-end workflow; add error handling, timeouts and output checks before use. Catalog presence is not proof of successful inference or current GPU stock.

The pipeline, stage by stage

An episode of a vertical short drama (a minute or two, 15–30 shots) breaks down like this:

The rule of thumb: anything stateless and prompt-driven goes to an API. Anything that needs your weights (a character LoRA, a custom ComfyUI graph) goes on a GPU you control, for as long as the render takes.

1. Script and shot list over an OpenAI-compatible API

The OpenAI Python and Node SDKs are documented for chat completions with a CloudGPU base URL and key; that does not imply every SDK feature is supported. A large model writes the episode and a fast one turns it into shots:

import os, json from openai import OpenAI client = OpenAI( api_key=os.environ["CLOUDGPU_API_KEY"], base_url="https://cloudgpu.app/v1", ) bible = open("series_bible.md").read() # characters, tone, recurring props  episode = client.chat.completions.create( model="deepseek-v4-pro", messages=[ {"role": "system", "content": "You write 90-second vertical drama episodes. Keep names and facts consistent with the bible."}, {"role": "user", "content": bible + "\n\nWrite episode 4: the sister finds the letter."}, ], ).choices[0].message.content shots = client.chat.completions.create( model="deepseek-v4-flash", response_format={"type": "json_object"}, messages=[ {"role": "system", "content": 'Split the script into shots. Return {"shots":[{"id":1,"seconds":4,"image_prompt":"...","motion_prompt":"...","line":"..."}]}'}, {"role": "user", "content": episode}, ], ).choices[0].message.content shots = json.loads(shots)["shots"] print(len(shots), "shots") 

Keep the bible as a file in the repo and send it with every episode. It can help consistency, but review each generated script; it is not a guarantee.

2. Quick shots through the video endpoint

For establishing shots and B-roll that don't need a locked character, a video job is enough. It's asynchronous: create, poll, download.

import time, requests H = {"Authorization": "Bearer " + os.environ["CLOUDGPU_API_KEY"]} BASE = "https://cloudgpu.app/v1" job = requests.post(f"{BASE}/videos", headers=H, json={ "model": "wan-3.0", "prompt": shots[0]["image_prompt"] + ". " + shots[0]["motion_prompt"], }).json() while True: status = requests.get(f"{BASE}/videos/{job['id']}", headers=H).json()["status"] if status in ("completed", "failed"): break time.sleep(10) if status == "completed": mp4 = requests.get(f"{BASE}/videos/{job['id']}/content", headers=H) open("shot_01.mp4", "wb").write(mp4.content) 

Optional fields (resolution, seconds, and image for models that accept images) are listed in the API docs. The current catalog lists wan-3.0 as text-to-video only; use an image-capable model for image-to-video. Finished files are downloadable for 24 hours, so pull them into your own storage.

3. Character shots on a rented GPU

When the lead has to look the same in every shot, you want your own LoRA and your own ComfyUI graph. VRAM requirements depend on the workflow, precision, resolution and offloading. CloudGPU's published Wan 2.2 test reports about 21 GB peak VRAM for its tested 14B FP8 configuration; do not treat 24 GB or 48 GB as a universal requirement.

Instead of buying that card, start one only for the render batch. The GPU API documents server-enforced auto-shutdown limits. Set and monitor appropriate limits; they do not replace copying outputs before destruction:

templates = requests.get(f"{BASE}/gpu/templates", headers=H).json() comfy = next(t for t in templates["data"] if "comfyui" in t["name"].lower()) inst = requests.post(f"{BASE}/gpu/instances", headers=H, json={ "template": comfy["id"], "gpu_model": "auto", # or pick a card from GET /gpu/offers  "idle_minutes": 30, # destroy after 30 idle minutes  "max_minutes": 240, # hard cap for this batch }).json() print(inst["id"], inst["status"]) 

Then SSH in, pull your LoRA and workflow, queue the shots, copy the MP4s out, and destroy the instance (DELETE /gpu/instances/{id}). Billing is per minute, rounded up, with a 1-minute minimum; billing stops when you destroy the instance. Check the live deploy page for which cards are available that day.

(The response shape above is simplified; check GET /v1/gpu/templates once and adjust the field names to what it returns.)

4. Voice and subtitles

Both are OpenAI-format audio endpoints, so the same client works:

speech = client.audio.speech.create(model="kokoro-tts", voice="af_heart", input=shots[0]["line"]) speech.write_to_file("line_01.mp3") with open("episode_04_rough.mp4", "rb") as f: srt = client.audio.transcriptions.create(model="whisper-v3-turbo", file=f, response_format="srt") open("episode_04.srt", "w").write(srt) 

(Voice names depend on the TTS model; list them from the docs.)

Rent or buy?

We won't quote prices here because they move. Do the math with your own numbers:

• Hours per month you actually need a big card (renders + LoRA training, not editing).
• The card's local price today, plus the RAM and SSD you'd also upgrade.
• How long until you'd upgrade again.

If the big-card hours are a few sessions a month, renting keeps the money in your pocket and nothing sits idle. Daily rendering can change the calculation; compare hardware, electricity, utilization and cloud costs rather than assuming buying always wins.

That's also the takeaway from ep05: buy what you need, don't hoard, and for the occasional big job, rent the kitchen instead of building one.

• Video: Will phones and computers cost more next year? — https://youtu.be/XSiCDC8v18Y
• Per-stage GPU guide for short dramas: https://cloudgpu.app/cloud-gpu-for-ai-short-drama?utm_source=devto&utm_medium=article&utm_campaign=202611_seg03_freelancer_gpu_api&utm_content=devto_drama_pipeline_rent

Disclosure: I work on CloudGPU. The API and GPU calls above are CloudGPU's; the pipeline is a proposal, and endpoint, model and GPU capabilities differ by provider. Pay by card or USDT; see /payments for the current list of methods.

Sources checked 2026-11-07: API docs, model catalog, billing terms, published short-drama workflow and test settings.