P-Video-2

Introduction

Video generation bills per second of finished output, and most of the seconds you generate while finding a shot get thrown away. The staging was wrong, the light was not the light the brand uses, the motion read as cheap. You pay full rate to learn that.

settings.draft is the answer to that specific waste. It runs the same request at lower quality and a lower per-second rate, fast enough to iterate against, so the expensive render happens once you already know what you are asking for. What it previews is the direction, not the frame, and that distinction runs through everything below.

Same prompt, same seed, one boolean apart, and the staging is not the same. Both are gold on travertine with one hard shaft of light, which is the part you were testing. Neither is a preview of the other's exact frame. This guide covers the flag, what draft actually answers, the loop it is built for, and what a seed does and does not hold.

The flag

settings.draft is a boolean and it is off unless you set it, so every call is full quality by default.

import { createClient } from '@runware/sdk'

const client = await createClient({ apiKey: process.env.RUNWARE_API_KEY })
await client.connect()

const [result] = await client.run({
  model: 'prunaai:p-video@2',
  positivePrompt: 'A slim brushed gold signet ring standing upright in a narrow slot cut into a block of pale travertine, a hard shaft of sunlight tracking slowly across the stone and catching the polished face of the ring. Deep shadow around it, warm neutral background. Photoreal fine jewellery cinematography, locked-off camera, no text, no hands.',
  resolution: '1080p',
  duration: 5,
  settings: {
    draft: true
  },
  seed: 5192740,
  deliveryMethod: 'async'
})

import asyncio
import os

from runware import Runware


async def main():
    async with Runware(api_key=os.environ["RUNWARE_API_KEY"]) as client:
        results = await client.run({
            "model": "prunaai:p-video@2",
            "positivePrompt": "A slim brushed gold signet ring standing upright in a narrow slot cut into a block of pale travertine, a hard shaft of sunlight tracking slowly across the stone and catching the polished face of the ring. Deep shadow around it, warm neutral background. Photoreal fine jewellery cinematography, locked-off camera, no text, no hands.",
            "resolution": "1080p",
            "duration": 5,
            "settings": {
                "draft": True
            },
            "seed": 5192740,
            "deliveryMethod": "async"
        })


asyncio.run(main())

curl https://api.runware.ai/v1 \
  -H "Authorization: Bearer $RUNWARE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '[
    {
      "taskType": "videoInference",
      "taskUUID": "7b2d9c41-5e83-4a06-9f17-3c8a2d5e1b74",
      "model": "prunaai:p-video@2",
      "positivePrompt": "A slim brushed gold signet ring standing upright in a narrow slot cut into a block of pale travertine, a hard shaft of sunlight tracking slowly across the stone and catching the polished face of the ring. Deep shadow around it, warm neutral background. Photoreal fine jewellery cinematography, locked-off camera, no text, no hands.",
      "resolution": "1080p",
      "duration": 5,
      "settings": {
        "draft": true
      },
      "seed": 5192740,
      "deliveryMethod": "async"
    }
  ]'

runware run prunaai:p-video@2 \
  positivePrompt="A slim brushed gold signet ring standing upright in a narrow slot cut into a block of pale travertine, a hard shaft of sunlight tracking slowly across the stone and catching the polished face of the ring. Deep shadow around it, warm neutral background. Photoreal fine jewellery cinematography, locked-off camera, no text, no hands." \
  resolution=1080p \
  duration=5 \
  settings.draft=true \
  seed=5192740 \
  deliveryMethod=async

{
  "taskType": "videoInference",
  "taskUUID": "7b2d9c41-5e83-4a06-9f17-3c8a2d5e1b74",
  "model": "prunaai:p-video@2",
  "positivePrompt": "A slim brushed gold signet ring standing upright in a narrow slot cut into a block of pale travertine, a hard shaft of sunlight tracking slowly across the stone and catching the polished face of the ring. Deep shadow around it, warm neutral background. Photoreal fine jewellery cinematography, locked-off camera, no text, no hands.",
  "resolution": "1080p",
  "duration": 5,
  "settings": {
    "draft": true
  },
  "seed": 5192740,
  "deliveryMethod": "async"
}

[
  {
    "taskType": "videoInference",
    "taskUUID": "7b2d9c41-5e83-4a06-9f17-3c8a2d5e1b74",
    "videoUUID": "4e8a1c73-2d95-4b60-8f21-9a5c7d3f1e28",
    "videoURL": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/4e8a1c73-2d95-4b60-8f21-9a5c7d3f1e28.mp4"
  }
]

Nothing else about the request changes, which is the property that makes the loop work: one boolean flips a call between exploring and delivering, so the same code path serves both and there is no separate preview endpoint to maintain.

What draft trades away

What you lose is rendering quality inside the frame. Fine texture goes soft and small detail is approximated rather than resolved. On a macro of a brushed metal surface, that is the entire subject:

There is a second, larger thing draft does not preserve, and it catches people who expect a preview: the flag changes the generation, not just the render. Run one prompt on one seed with the flag on and off and you get two different stagings, every time. The subject, the palette, the light quality and the material all carry over. The exact framing does not.

That sets the boundary of what a draft can answer. A draft settles direction-level questions: is this the right look, is the light doing what I asked, is the material reading as metal, is the concept worth paying for. It cannot settle frame-level questions, because the frame will move, and it cannot settle finish-level ones, because the finish is what draft approximates.

The rule that falls out: judge the direction in draft, judge the frame and the material at full quality. Comparing a brushed finish against a polished one in draft is comparing two approximations of the difference you are trying to see, in two shots that are not the same shot.

The output dimensions are identical in both modes, and so is the frame rate. A 1080p draft is 1920 × 1088 and so is a 1080p final; a 720p draft is 1280 × 704 and so is a 720p final. The flag changes what is rendered inside those frames, not how many pixels you get, so a draft is a fair preview of framing and a poor preview of finish.

The iteration loop

The loop is cheap exploration, then one expensive commit. Three stagings of the same product, all in draft:

Three drafts and one final costs less than three full renders, and the saving scales with duration, because the discount is per second. That has a second implication worth acting on: where a decision can be made on a 3-second version of a 10-second shot, test on the short one. Cutting the length is a bigger saving than the flag is, and the two multiply.

Two things do not belong in the loop. Anything with a person speaking should be judged at full quality, because lip sync is a fine-detail behavior and a soft mouth is hard to assess. And anything where the deliverable is the texture goes straight to full, since the draft cannot show you the thing being sold.

What a seed holds

Every call renders fresh, so the same prompt gives a different clip each time unless you pin seed. It takes an integer from 0 to 2147483647, and omitting it draws a random one.

A seed only holds if nothing else is rewriting the request. settings.promptUpsampling defaults to true and rewrites your prompt differently on every call, so a pinned seed reproduces nothing until you turn it off. Send the same request twice with the expander off and the two files come back identical; leave it on and they do not. The prompt expander section covers it.

{
  "seed": 5192740
}

Two seeds against one prompt shows how much moves when nothing else changes:

Same brief, two different shots. That matters for a catalog, where a set of products has to look like one shoot, and a shared seed across the set is what holds the staging and the light together while only the product changes. It is the same mechanism as the variant sets built from stills.

What a seed does not do is carry a draft across to full quality. Dropping the flag changes the generation, so the number that produced a draft you liked will not reproduce it at full quality. Approving a draft approves the direction, and the final run is its own take on that direction.

When a specific composition has to survive to the final render, the flag is the wrong tool. Lock the frame you approved and drive the delivery from it as an image-to-video request, which is the only thing that holds a composition across a change of settings.

Tips

1. Draft anything you have not run before. The first question is usually "did this produce the shot at all", and draft answers it at a lower rate.

2. Explore in draft, deliver at full. Three drafts and one final beats three finals, and the gap widens with duration.

3. Shorten the clip as well as flipping the flag. Per-second billing means a 3-second draft of a 10-second shot is the bigger saving of the two, and they compound.

4. Judge direction in draft, frame and finish at full. Look, palette, light quality and concept carry over. The exact staging and the texture do not.

5. Never judge lip sync in draft. Mouth detail is the first thing softened, and it is the thing you would be checking.

6. Pin a seed before you start iterating. Changing a prompt against a moving seed tells you nothing about the prompt.

7. Do not expect a draft to survive promotion. Dropping the flag regenerates the shot. A draft approves the direction; if the exact frame matters, anchor it with a first frame instead.

8. Share one seed across a product set. It is what makes six clips read as one shoot instead of six.

9. Store what you approved. A seed gets you close on a rerun. The file you already have is the only exact copy.