Field SOP
Field SOP

Wan3.0 Hands-On SOP: The Full Pipeline from PPT to a 30-Second Finished Video

On 2026-08-24 Alibaba Cloud Bailian launched Wan3.0-Video: first-ever direct PPT/PDF/Word document input, 2-30 second single generations across 480P/720P/1080P, API billed per second at 0.3/0.6/1.2 CNY. This SOP walks the full pipeline from document to 30-second finished film: Bailian keys and region consistency, the zero-code entry points, the DashScope SDK (>=1.25.16) with async polling and the 24-hour video_url window, a timestamped storyboard prompt template, and the file-or-link reference-video workflow - plus a cost table (1080P/30s at 36 CNY list, 25.2 CNY on the 30% promo, 60-80 CNY with gacha budget) and 7 pitfalls.

Published August 25, 20268 min read
<!-- wan3-0-doc-to-video-sop | sop | Wan3.0 Hands-On SOP: The Full Pipeline from PPT to a 30-Second Finished Video -->

On 2026-08-24, Alibaba Cloud's Bailian platform officially launched Wan3.0-Video (model name wan3.0-video): single-shot generation of 2-30 seconds (whole seconds), 480P/720P/1080P, and - for the first time - direct input of doc, xls, ppt, pdf, and md documents. Turning a PPT deck into a 30-second finished video went from a three-step "screenshot first, then image-to-video" routine to a one-step "upload the document, write one storyboard description" operation (background in our Wan3.0 launch coverage).

This SOP answers one concrete question: starting from zero, how do you turn a document into a usable 30-second video? The path runs in four stages: account and key -> zero-code trial -> SDK integration -> storyboard prompting and the document-direct workflow. All parameters come from the official Bailian docs (updated 2026-08-18) and the Alibaba Cloud Developer Community article (verified 2026-08-24/25).

Three boundaries up front. First, this is not an official partnership or promotion - prices and promotions change, and the Bailian console page is the source of truth. Second, 2-30 seconds is the per-request cap; anything longer means generating segments and stitching them in an editor. Third, video generation is a gacha game - any expectation of "one shot, one finished film" will be priced into you by the cost table below.

Stage 0: Account, Key, and Region Consistency

Enable the service in the Bailian console and create an API key. Three hard rules:

  1. Keys go into environment variables - never into code, never into prompts. In Python, os.getenv("DASHSCOPE_API_KEY") is the only correct posture.
  2. Model, endpoint, and key must be in the same region. Wan3.0 uses regionalized endpoints: https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1 (each region has its own URL and API key). A Beijing key hitting a Singapore endpoint fails outright. The official docs bold-flag this as pitfall number one.
  3. Understand the billing model. Video generation bills per second; failed tasks aren't charged, but successful ones are charged on completion - so "test small before scaling up" isn't a slogan, it's a savings strategy.

Stage 1: The Zero-Code Path - Nail the Flow in the Console First

Not everyone needs to write code. Wan3.0 ships with 8 experience entry points: Alibaba Cloud Bailian, the Wanxiang official site, Wanjing Yike, the Qwen AI platform, Qwen Creation for PC, the Qwen app, Duifan, and IF STUDIO.

Shortest path for non-developers: in the Bailian console or the Qwen app, pick wan3.0-video, upload your PPT/PDF directly, fill in one storyboard description, choose resolution and duration, and hit generate. The real value of this step isn't the output - it's validating two things: whether the model can parse your document's structure, and whether your storyboard description produces the visuals you want. Testing these in the console is cheap (some entry points offer free quota); testing them against the API bills per second.

Developers should take this step too: tune the prompt in the console until it's 80-90% right, then move it into code. Gacha-testing straight against the API burns your own bill.

Stage 2: SDK Integration - Async Calls, Polling, Download Within 24 Hours

The DashScope Python SDK must be ≥ 1.25.16 - older versions throw url error, please check url!:

bash
pip install dashscope --upgrade
python -c "import dashscope; print(dashscope.__version__)"

The official synchronous example (note the regionalized endpoint on line one):

python
import os
from http import HTTPStatus
from dashscope import VideoSynthesis
import dashscope

dashscope.base_http_api_url = 'https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1'
api_key = os.getenv("DASHSCOPE_API_KEY")

rsp = VideoSynthesis.call(api_key=api_key,
                          model='wan3.0-video',
                          prompt='Shot 1... Shot 2...',
                          resolution="720P",
                          ratio="16:9",
                          duration=15,
                          watermark=True)
if rsp.status_code == HTTPStatus.OK:
    print("video_url:", rsp.output.video_url)

Three things your engineering must handle:

  • Async and polling: video generation is an asynchronous task that returns a task_id and task_status. Poll until SUCCEEDED to get the video_url; on FAILED, stop and log the reason - never wait indefinitely. A 10-minute timeout with at most 2 retries is a sane default.
  • The 24-hour window: the video_url is valid for only 24 hours. Download immediately on completion and archive long-term assets to OSS; don't discover the link expired before you saved the file.
  • Result archival: log task_id, the full prompt, parameters, latency, and cost together. Gacha post-mortems without logs are guesswork.

Stage 3: The Storyboard Prompt Template - A Copyable Universal Structure

Multi-shot output in Wan3.0 requires no special parameters: describe the shot structure in natural language (the old wan2.6 model needed shot_type="multi" + prompt_extend=true). If you don't describe a structure, the model decides single- vs multi-shot on its own - if you want control, write the structure yourself, timestamps included.

The universal template:

Prompt
[One opening line setting the tone: style + subject + framing mood]
Shot 1 [0-2s]: camera/movement + subject + what's in frame + emotion
Shot 2 [2-5s]: camera/movement + subject + what's in frame + emotion
Shot 3 [5-8s]: camera/movement + subject + what's in frame + emotion
Shot 4 [8-10s]: camera/movement + subject + what's in frame + emotion
[Closing: music / rhythm / atmosphere description]

Per-shot formula: camera + movement + subject + frame + emotion. Whichever element you leave out is the one the model improvises.

A filled-in example (document-direct scenario, a PPT-to-product-teaser):

Prompt
A modern, tech-forward product teaser film, cool tones, clean and minimal.
Shot 1 [0-3s]: overhead camera slowly descending, a product whitepaper spread open on a white desk, the architecture diagram on the page clearly visible, professional and calm.
Shot 2 [3-8s]: eye-level push-in, modules in the diagram light up one by one and float off the page, assembling into a product interface mid-air, the tech vibe building.
Shot 3 [8-13s]: orbiting camera, the floating modules rotate and reassemble into the product logo, light converging.
Shot 4 [13-15s]: hold, the logo settles back onto the paper, the desk returns to order, a sense of closure.
Music: light electronic beat, building with each shot, ending on one clean accent hit.

Two structures from the official examples are worth stealing: the five-shot cheetah-chasing-gazelle storyboard (extreme wide low-angle push-in -> lateral parallel tracking -> inside-arc orbit -> zoom push -> ground-level approach, with the music's rhythm written into the prompt), and the four-shot floating-garden future-city piece (the [0-2s][2-4s][4-7s][7-10s] timestamp style). The common thread: movement trajectories are specific down to direction, emotion escalates, and the music has a described rhythm.

Stage 4: The Document-Direct Workflow - Feeding PPT/Excel to the Model

Wan3.0's reference-based generation supports four modes: text-to-video, image-to-video (first frame / first+last frame), reference-based video, and multimodal-fusion driving. Document-direct input is a form of reference-based video, with two input methods:

  • type:"file": upload PDF/PPT/DOCX etc. Suited for brand-asset reuse, IP character extension, and tutorial-video automation - the official use cases of e-commerce product videos (first-frame control keeps the product pixel-faithful), advertising (brand VI / PPT to ad film in one shot), and education (PDF/Word courseware to explainer video, first+last frames for step-by-step demos) all live here.
  • type:"link": a public web URL, for when the source content lives online.

Hard limit: file and link cannot be used together - mixing them errors out immediately.

The recommended workflow: run one structural pass over the document first (distill each slide into one "what this page must convey" sentence), organize those sentences into a storyboard via the Stage-3 template, then submit the document together with the storyboard description. Dumping 30 pages of raw PPT in and hoping the model finds the point on its own will visibly tank your hit rate. Note that requests must be submitted asynchronously (the X-DashScope-Async: enable header; the SDK has the corresponding async call), with polling as in Stage 2.

Know the capability boundary too: Wan3.0-Video does not support batch inference, model fine-tuning, context caching, prefix continuation, Function Calling, web search, or structured output - don't expect it to "look things up online" or "return JSON" from a prompt. Adaptive-ratio output does let one generation fit Douyin/Instagram/YouTube framings.

Cost Estimate: From Gacha to Finished Film

Unit prices: 480P at 0.3 CNY/second, 720P at 0.6, 1080P at 1.2; a limited-time 30% off (7/10 of list) runs 8-24 through 9-23 on the Bailian and Qwen platform APIs.

PurposeResolutionDurationList price30% off
Prompt gacha test480P5 s1.5 CNY1.05 CNY
Storyboard validation480P15 s4.5 CNY3.15 CNY
First cut720P30 s18 CNY12.6 CNY
Delivery master1080P30 s36 CNY25.2 CNY

A working budget: for one 1080P/30-second finished video, assume "3 rounds of 480P tests + 2 rounds of 1080P generation," totaling roughly 60-80 CNY. The classic beginner mistake is testing prompts at full 1080P/30s - one miss is 36 CNY, three misses is a hundred-plus. Always tune the prompt at 480P and short durations before producing the master. For full pricing across six major video APIs, see our What a 30-Second 1080P Video Costs.

Seven Classic Pitfalls

  • SDK below 1.25.16 - throws url error, please check url!, an error message that never mentions version; expect half an hour of confusion. Print the version right after installing.
  • Not downloading before the 24-hour expiry - you remember the next day, the link 404s; the money was spent and the film is gone. The end of every generation job must be "download + archive."
  • Mixing file and link - reference-based input is either/or; passing both errors immediately, and the docs flag this in bold.
  • Cross-region key/endpoint mixing - model, endpoint, and key must be same-region; cross-region calls fail with unhelpful errors.
  • Testing prompts at the 30-second ceiling - generation is gacha; validate storyboard logic at 480P/5s for 1.5 CNY per shot instead of 36 CNY per miss.
  • Polling without a timeout - a task stuck in PENDING hangs your thread forever. Polling must terminate on SUCCEEDED/FAILED, with a timeout cap and a retry cap.
  • API key in the prompt or the frontend - prompts get logged wholesale, so the key lands in your logs; calling the API from a browser hands the key to every user.

Pre-Launch Checklist

  1. SDK ≥ 1.25.16, verified per deployment environment
  2. Endpoint, key, and model same-region, in config rather than code
  3. Keys via env vars/KMS; no plaintext in logs or prompts
  4. Polling with timeout (10 minutes suggested) + retry cap (2 suggested) + FAILED logged
  5. video_url download + OSS archival automated - no reliance on "remembering to save"
  6. task_id/prompt/params/cost fully logged for post-mortems
  7. Production flow fixed as "480P test -> tune prompt -> high-res master"
  8. file and link routed exclusively, with mutual-exclusion validation in code
  9. Per-second billing under monitoring, with a daily budget alert
  10. Content over 30 seconds planned as segments + stitching, never single-shot

One-line closer: document-direct input removed the "prepare your assets" barrier but raised the "write the storyboard" one - spend the saved time on the prompt, and the cost of a 30-second film can differ by more than 2x.

FAQ

Q1: I can't code - can I still use Wan3.0 for document-to-video? A1: Yes. Of the 8 entry points, the Bailian console, the Qwen app, and the Wanxiang site are all direct web/app operations: upload the document, fill in the storyboard description, pick parameters, generate. Use these to tune your prompt first, then decide whether you need the API for batching or automation.

Q2: The cap is 30 seconds per video - what about 1-minute content? A2: Generate in segments and stitch. Split the content into 2-4 segments of 15-30 seconds, generate each independently (noting in each prompt how the visuals and emotion carry over), and join them in an editor. Keep the style description consistent across prompts, or the segments will visually jump.

Q3: How much does one 30-second 1080P video cost? A3: List price is 36 CNY (1.2 CNY/s × 30s), about 25.2 CNY during the 8-24 to 9-23 promo. But budget for the gacha: 3 rounds of 480P tests plus 2 rounds of 1080P generation runs 60-80 CNY total. Testing prompts at the ceiling is the most expensive way to learn.

Q4: Document-direct input vs. screenshotting the PPT for image-to-video - which is better? A4: Different jobs. Document-direct (reference-based) suits letting the model understand the document's structure and improvise the visuals - PPT to teaser, courseware to explainer. Image-to-video (first/last frame) suits scenes that must stay faithful to the source - product hero images kept pixel-perfect. "Faithful reproduction" uses first-frame control; "creative transformation" uses document-direct.

Q5: My task has been PENDING forever - what's going on? A5: Video generation is asynchronous, and both queuing and generation take time; a 30-second master commonly waits on the order of minutes. First verify your polling logic (task_status read correctly), then check region consistency (cross-region calls can fail with delayed errors). Always cap your polling with a timeout; treat timeouts as failures and retry rather than waiting forever.


References

  • Alibaba Cloud Bailian official docs, Video Generation (updated 2026-08-18, verified 2026-08-25): https://help.aliyun.com/zh/model-studio/text-to-video-guide/ - SDK version, regionalized endpoint, the synchronous call example, multi-shot description, the 24-hour video_url window
  • Alibaba Cloud Developer Community, Wan3.0-Video launch (2026-08-24): https://developer.aliyun.com/article/1757799 - the four generation modes, reference-based file/link input, capability boundaries, use cases
  • Wan3.0 launch pricing and the 8 experience entry points (2026-08-24): 480P/720P/1080P unit prices and the limited-time 30% discount, subject to the live Bailian page

This article is based on official documentation (as of 2026-08-25) and is not an official partnership or promotion; prices and promotions follow the official Bailian page.

This article is AI-assisted and human-edited. Last updated: 2026-08-25

FAQ

I can't code - can I still use Wan3.0 for document-to-video?
Yes. Of the 8 entry points, the Bailian console, the Qwen app, and the Wanxiang site are all direct web/app operations: upload the document, fill in the storyboard description, pick parameters, generate. Use these to tune your prompt first, then decide whether you need the API for batching or automation.
The cap is 30 seconds per video - what about 1-minute content?
Generate in segments and stitch. Split the content into 2-4 segments of 15-30 seconds, generate each independently (noting in each prompt how the visuals and emotion carry over), and join them in an editor. Keep the style description consistent across prompts, or the segments will visually jump.
How much does one 30-second 1080P video cost?
List price is 36 CNY (1.2 CNY/s × 30s), about 25.2 CNY during the 8-24 to 9-23 promo. But budget for the gacha: 3 rounds of 480P tests plus 2 rounds of 1080P generation runs 60-80 CNY total. Testing prompts at the ceiling is the most expensive way to learn.
Document-direct input vs. screenshotting the PPT for image-to-video - which is better?
Different jobs. Document-direct (reference-based) suits letting the model understand the document's structure and improvise the visuals - PPT to teaser, courseware to explainer. Image-to-video (first/last frame) suits scenes that must stay faithful to the source - product hero images kept pixel-perfect. "Faithful reproduction" uses first-frame control; "creative transformation" uses document-direct.
My task has been PENDING forever - what's going on?
Video generation is asynchronous, and both queuing and generation take time; a 30-second master commonly waits on the order of minutes. First verify your polling logic (task_status read correctly), then check region consistency (cross-region calls can fail with delayed errors). Always cap your polling with a timeout; treat timeouts as failures and retry rather than waiting forever. --- **References** - Alibaba Cloud Bailian official docs, Video Generation (updated 2026-08-18, verified 2026-08-25): https://help.aliyun.com/zh/model-studio/text-to-video-guide/ - SDK version, regionalized endpoint, the synchronous call example, multi-shot description, the 24-hour video_url window - Alibaba Cloud Developer Community, Wan3.0-Video launch (2026-08-24): https://developer.aliyun.com/article/1757799 - the four generation modes, reference-based file/link input, capability boundaries, use cases - Wan3.0 launch pricing and the 8 experience entry points (2026-08-24): 480P/720P/1080P unit prices and the limited-time 30% discount, subject to the live Bailian page This article is based on official documentation (as of 2026-08-25) and is not an official partnership or promotion; prices and promotions follow the official Bailian page.

Related

Field SOP

17 Seconds on a CPU: Prove Which Model Answered You

Verify the cryptographic birth certificate of an AI reply on a plain CPU with the open-source FlashProve from Anthropic: prepare Linux (g++ 13 or later, non-root, under 2GB RAM; WSL2 as the common Windows route), clone anthropics/FlashProve (0.16.0), build with verifier/build.sh in one to two minutes, run the stored example under examples/accepted-proof (expect a final line YES, exit code 0, under 2 seconds), read results via the exit-code table (0 accepted, 1 rejected, 5 unchecked, 14 invalid call), then the real-world five-argument call and the rule that the commitment ID must come from a trusted third party. Honest limits throughout: it proves provenance not correctness, a 1024-token context, officially not maintained, and no major provider ships proofs yet.

Nov 5, 20269 min read
Field SOP

Wire Hy4 In With Three Params: Five Steps and Three Traps

A five-step guide to wiring the final Tencent Hunyuan Hy4 API into your own workflow: create a console key and enable the model (a 402 means it is not enabled), change only base URL, API key and model (two regional endpoints, three protocol paths), keep the platform name hy4 distinct from the OpenRouter name tencent/hy4, feed images with the documented image_url and base64 pattern, then plug into CodeBuddy, Claude Code and similar clients and verify. Includes runnable Python, the 401002/402xxx/429xxx error codes, SSE mid-stream error frames, thinking mode, and three separate pricing regimes.

Nov 4, 20269 min read
Field SOP

Build Long-Running Agent Workflows with GPT-6 Astra

A hands-on SOP for building long-running agent workflows on GPT-6 Astra's real capabilities (1.05M context, 128K output, 0% alignment overreach): start with three prerequisites (OpenAI Python SDK 1.50+, the OPENAI_API_KEY environment variable, and API allowlist), then proceed in order through long-context planning, tool definition (function calling plus computer use), async invocation, mid-flight correction, and acceptance with cost control. Key points: on the first call place only the goal, acceptance criteria, tool list, and key background so the model emits a plan first; tools must specify name, description, and parameters; use streaming events plus a background queue and task-id polling for async; correct course by injecting new instructions without restart; and accept only via independent assertion scripts while keeping max_output_tokens small and setting a daily spend cap.

Sep 4, 202611 min read