Skip to content

AIExplore

How to Use Runway Image Generation

Create Runway stills with Gen-4 Image or Image Turbo, match ratios for later motion, and review frames before spending video credits.

Runway image generation creates stills you can publish as is or feed into Image to Video. Official academy model listings show Gen-4 Image for text to image and image to image with resolution based credits, for example 5 credits at 720p and 8 credits at 1080p, and Gen-4 Image Turbo at 2 credits per image. Credits are shared with video on paid plans. Free plan users get a limited tool set and watermarks per Free plan help. Start at /explore/runway.

This guide focuses on stills that survive motion: clear composition, simple shapes where needed, and aspect ratios that match later video. Continue with /blog/how-to-use-runway-image-to-video-generation and /blog/how-to-use-runway-text-to-video-generation.

When to generate a still first

Generate a still when you need client approval on look before spending video credits, when product geometry must stay exact, or when you want a library of first frames for Animate Frames or Image to Video.

Step by step image workflow

1. Define the still job

Poster, thumbnail, storyboard keyframe, or Image to Video first frame. That choice drives aspect ratio and how much fine detail you allow.

Scenario:
A realistic runway workflow is being prepared for Use Runway Text to Video Generation using runway. The starting requirement is: Still job card Use: Image to Video first frame Ratio: 9:16 Subject: matte bottle on wet stone Lighting: soft overcast Style: photoreal product Text: none Model: Gen-4 Image or Gen-4 Image Turbo for drafts. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Still job card Use: Image to Video first frame Ratio: 9:16 Subject: matte bottle on wet stone Lighting: soft overcast Style: photoreal product Text: none Model: Gen-4 Image or Gen-4 Image Turbo for drafts" that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Inputs:
Use the actual source material required for this task, together with the intended audience, destination, format, and quality requirements. Specify relevant files, text, URLs, structured data, reference assets, dimensions, language, tone, timing, model or generation settings, credentials, field mappings, or integration values when they apply. Keep secrets out of the example and use the product's supported credential or configuration mechanism.

Workflow:
1. Start with one representative input that contains the important characteristics of the real workload.
2. Configure runway specifically for the requested task and make the important settings explicit.
3. Run the first pass and inspect the result against the objective.
4. Correct only the settings or source material responsible for a failed requirement instead of changing everything at once.
5. Validate the intermediate result before passing it to the next step.
6. When the result meets the requirements, save the successful configuration so the same process can be repeated consistently.
7. If this is a multi-step workflow, verify each handoff and keep a clear fallback or review path for failures.

Requirements:
The example must use supported functionality only. Do not invent product features, pricing, limits, integrations, model names, API behavior, or unavailable settings. Preserve important source data and formatting. Validate required fields before processing, handle empty or invalid input explicitly, prevent accidental duplicate processing where relevant, and stop or route the item for review when a required step fails. For credentials, use the supported secure configuration rather than placing secrets directly in the content.

Expected output:
The final result should directly satisfy the "Still job card Use: Image to Video first frame Ratio: 9:16 Subject: matte bottle on wet stone Lighting: soft overcast Style: photoreal product Text: none Model: Gen-4 Image or Gen-4 Image Turbo for drafts" requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

2. Prompt one scene clearly

Describe subject, composition, lighting, and style. Spell any required text exactly or say no text. Avoid packing five locations into one still.

Scenario:
A realistic runway workflow is being prepared for Use Runway Text to Video Generation using runway. The starting requirement is: Image prompt Studio product photo of a matte black wireless earbud case on seamless light gray. Soft top light, subtle reflection, centered composition, no text, no watermark. 1:1.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Image prompt Studio product photo of a matte black wireless earbud case on seamless light gray. Soft top light, subtle reflection, centered composition, no text, no watermark. 1:1." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Inputs:
Use the actual source material required for this task, together with the intended audience, destination, format, and quality requirements. Specify relevant files, text, URLs, structured data, reference assets, dimensions, language, tone, timing, model or generation settings, credentials, field mappings, or integration values when they apply. Keep secrets out of the example and use the product's supported credential or configuration mechanism.

Workflow:
1. Start with one representative input that contains the important characteristics of the real workload.
2. Configure runway specifically for the requested task and make the important settings explicit.
3. Run the first pass and inspect the result against the objective.
4. Correct only the settings or source material responsible for a failed requirement instead of changing everything at once.
5. Validate the intermediate result before passing it to the next step.
6. When the result meets the requirements, save the successful configuration so the same process can be repeated consistently.
7. If this is a multi-step workflow, verify each handoff and keep a clear fallback or review path for failures.

Requirements:
The example must use supported functionality only. Do not invent product features, pricing, limits, integrations, model names, API behavior, or unavailable settings. Preserve important source data and formatting. Validate required fields before processing, handle empty or invalid input explicitly, prevent accidental duplicate processing where relevant, and stop or route the item for review when a required step fails. For credentials, use the supported secure configuration rather than placing secrets directly in the content.

Expected output:
The final result should directly satisfy the "Image prompt Studio product photo of a matte black wireless earbud case on seamless light gray. Soft top light, subtle reflection, centered composition, no text, no watermark. 1:1." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

3. Review for motion readiness

Before animating, check hands, edges, logos, and tiny text. Simplify shapes if you expect camera motion that will expose artifacts.

Scenario:
A realistic runway workflow is being prepared for Use Runway Text to Video Generation using runway. The starting requirement is: Motion readiness [ ] Edges clean [ ] No accidental text [ ] Subject scale fits future camera move [ ] Lighting direction is intentional [ ] Ratio matches video plan. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Motion readiness [ ] Edges clean [ ] No accidental text [ ] Subject scale fits future camera move [ ] Lighting direction is intentional [ ] Ratio matches video plan" that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Inputs:
Use the actual source material required for this task, together with the intended audience, destination, format, and quality requirements. Specify relevant files, text, URLs, structured data, reference assets, dimensions, language, tone, timing, model or generation settings, credentials, field mappings, or integration values when they apply. Keep secrets out of the example and use the product's supported credential or configuration mechanism.

Workflow:
1. Start with one representative input that contains the important characteristics of the real workload.
2. Configure runway specifically for the requested task and make the important settings explicit.
3. Run the first pass and inspect the result against the objective.
4. Correct only the settings or source material responsible for a failed requirement instead of changing everything at once.
5. Validate the intermediate result before passing it to the next step.
6. When the result meets the requirements, save the successful configuration so the same process can be repeated consistently.
7. If this is a multi-step workflow, verify each handoff and keep a clear fallback or review path for failures.

Requirements:
The example must use supported functionality only. Do not invent product features, pricing, limits, integrations, model names, API behavior, or unavailable settings. Preserve important source data and formatting. Validate required fields before processing, handle empty or invalid input explicitly, prevent accidental duplicate processing where relevant, and stop or route the item for review when a required step fails. For credentials, use the supported secure configuration rather than placing secrets directly in the content.

Expected output:
The final result should directly satisfy the "Motion readiness [ ] Edges clean [ ] No accidental text [ ] Subject scale fits future camera move [ ] Lighting direction is intentional [ ] Ratio matches video plan" requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Practical image use cases

Product hero still

Scenario:
A realistic runway workflow is being prepared for Use Runway Text to Video Generation using runway. The starting requirement is: Matte ceramic pour over on walnut board. Soft window light from left. Shallow depth of field. Centered. No logos. 16:9.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Matte ceramic pour over on walnut board. Soft window light from left. Shallow depth of field. Centered. No logos. 16:9." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Inputs:
Use the actual source material required for this task, together with the intended audience, destination, format, and quality requirements. Specify relevant files, text, URLs, structured data, reference assets, dimensions, language, tone, timing, model or generation settings, credentials, field mappings, or integration values when they apply. Keep secrets out of the example and use the product's supported credential or configuration mechanism.

Workflow:
1. Start with one representative input that contains the important characteristics of the real workload.
2. Configure runway specifically for the requested task and make the important settings explicit.
3. Run the first pass and inspect the result against the objective.
4. Correct only the settings or source material responsible for a failed requirement instead of changing everything at once.
5. Validate the intermediate result before passing it to the next step.
6. When the result meets the requirements, save the successful configuration so the same process can be repeated consistently.
7. If this is a multi-step workflow, verify each handoff and keep a clear fallback or review path for failures.

Requirements:
The example must use supported functionality only. Do not invent product features, pricing, limits, integrations, model names, API behavior, or unavailable settings. Preserve important source data and formatting. Validate required fields before processing, handle empty or invalid input explicitly, prevent accidental duplicate processing where relevant, and stop or route the item for review when a required step fails. For credentials, use the supported secure configuration rather than placing secrets directly in the content.

Expected output:
The final result should directly satisfy the "Matte ceramic pour over on walnut board. Soft window light from left. Shallow depth of field. Centered. No logos. 16:9." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Social thumbnail

Scenario:
A realistic runway workflow is being prepared for Use Runway Text to Video Generation using runway. The starting requirement is: Bold flat illustration of headphones on coral background. Thick shapes, limited palette, large negative space for later title safe area. No text. 1:1.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Bold flat illustration of headphones on coral background. Thick shapes, limited palette, large negative space for later title safe area. No text. 1:1." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Inputs:
Use the actual source material required for this task, together with the intended audience, destination, format, and quality requirements. Specify relevant files, text, URLs, structured data, reference assets, dimensions, language, tone, timing, model or generation settings, credentials, field mappings, or integration values when they apply. Keep secrets out of the example and use the product's supported credential or configuration mechanism.

Workflow:
1. Start with one representative input that contains the important characteristics of the real workload.
2. Configure runway specifically for the requested task and make the important settings explicit.
3. Run the first pass and inspect the result against the objective.
4. Correct only the settings or source material responsible for a failed requirement instead of changing everything at once.
5. Validate the intermediate result before passing it to the next step.
6. When the result meets the requirements, save the successful configuration so the same process can be repeated consistently.
7. If this is a multi-step workflow, verify each handoff and keep a clear fallback or review path for failures.

Requirements:
The example must use supported functionality only. Do not invent product features, pricing, limits, integrations, model names, API behavior, or unavailable settings. Preserve important source data and formatting. Validate required fields before processing, handle empty or invalid input explicitly, prevent accidental duplicate processing where relevant, and stop or route the item for review when a required step fails. For credentials, use the supported secure configuration rather than placing secrets directly in the content.

Expected output:
The final result should directly satisfy the "Bold flat illustration of headphones on coral background. Thick shapes, limited palette, large negative space for later title safe area. No text. 1:1." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Storyboard start frame

Scenario:
A realistic runway workflow is being prepared for Use Runway Text to Video Generation using runway. The starting requirement is: Wide establishing shot of a rainy neon alley. Photoreal. Wet asphalt reflections. Empty street. Moody teal amber. 21:9.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Wide establishing shot of a rainy neon alley. Photoreal. Wet asphalt reflections. Empty street. Moody teal amber. 21:9." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Inputs:
Use the actual source material required for this task, together with the intended audience, destination, format, and quality requirements. Specify relevant files, text, URLs, structured data, reference assets, dimensions, language, tone, timing, model or generation settings, credentials, field mappings, or integration values when they apply. Keep secrets out of the example and use the product's supported credential or configuration mechanism.

Workflow:
1. Start with one representative input that contains the important characteristics of the real workload.
2. Configure runway specifically for the requested task and make the important settings explicit.
3. Run the first pass and inspect the result against the objective.
4. Correct only the settings or source material responsible for a failed requirement instead of changing everything at once.
5. Validate the intermediate result before passing it to the next step.
6. When the result meets the requirements, save the successful configuration so the same process can be repeated consistently.
7. If this is a multi-step workflow, verify each handoff and keep a clear fallback or review path for failures.

Requirements:
The example must use supported functionality only. Do not invent product features, pricing, limits, integrations, model names, API behavior, or unavailable settings. Preserve important source data and formatting. Validate required fields before processing, handle empty or invalid input explicitly, prevent accidental duplicate processing where relevant, and stop or route the item for review when a required step fails. For credentials, use the supported secure configuration rather than placing secrets directly in the content.

Expected output:
The final result should directly satisfy the "Wide establishing shot of a rainy neon alley. Photoreal. Wet asphalt reflections. Empty street. Moody teal amber. 21:9." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Storyboard end frame

Scenario:
A realistic runway workflow is being prepared for Use Runway Text to Video Generation using runway. The starting requirement is: Same alley, camera much closer to a glowing vending machine. Matching rain and color grade. No new props. 21:9.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Same alley, camera much closer to a glowing vending machine. Matching rain and color grade. No new props. 21:9." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Inputs:
Use the actual source material required for this task, together with the intended audience, destination, format, and quality requirements. Specify relevant files, text, URLs, structured data, reference assets, dimensions, language, tone, timing, model or generation settings, credentials, field mappings, or integration values when they apply. Keep secrets out of the example and use the product's supported credential or configuration mechanism.

Workflow:
1. Start with one representative input that contains the important characteristics of the real workload.
2. Configure runway specifically for the requested task and make the important settings explicit.
3. Run the first pass and inspect the result against the objective.
4. Correct only the settings or source material responsible for a failed requirement instead of changing everything at once.
5. Validate the intermediate result before passing it to the next step.
6. When the result meets the requirements, save the successful configuration so the same process can be repeated consistently.
7. If this is a multi-step workflow, verify each handoff and keep a clear fallback or review path for failures.

Requirements:
The example must use supported functionality only. Do not invent product features, pricing, limits, integrations, model names, API behavior, or unavailable settings. Preserve important source data and formatting. Validate required fields before processing, handle empty or invalid input explicitly, prevent accidental duplicate processing where relevant, and stop or route the item for review when a required step fails. For credentials, use the supported secure configuration rather than placing secrets directly in the content.

Expected output:
The final result should directly satisfy the "Same alley, camera much closer to a glowing vending machine. Matching rain and color grade. No new props. 21:9." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Character reference

Scenario:
A realistic runway workflow is being prepared for Use Runway Text to Video Generation using runway. The starting requirement is: Portrait of a woman in a yellow raincoat under a streetlamp. Sharp eyes, soft background bokeh, film still look. No watermark. 3:4.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Portrait of a woman in a yellow raincoat under a streetlamp. Sharp eyes, soft background bokeh, film still look. No watermark. 3:4." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Inputs:
Use the actual source material required for this task, together with the intended audience, destination, format, and quality requirements. Specify relevant files, text, URLs, structured data, reference assets, dimensions, language, tone, timing, model or generation settings, credentials, field mappings, or integration values when they apply. Keep secrets out of the example and use the product's supported credential or configuration mechanism.

Workflow:
1. Start with one representative input that contains the important characteristics of the real workload.
2. Configure runway specifically for the requested task and make the important settings explicit.
3. Run the first pass and inspect the result against the objective.
4. Correct only the settings or source material responsible for a failed requirement instead of changing everything at once.
5. Validate the intermediate result before passing it to the next step.
6. When the result meets the requirements, save the successful configuration so the same process can be repeated consistently.
7. If this is a multi-step workflow, verify each handoff and keep a clear fallback or review path for failures.

Requirements:
The example must use supported functionality only. Do not invent product features, pricing, limits, integrations, model names, API behavior, or unavailable settings. Preserve important source data and formatting. Validate required fields before processing, handle empty or invalid input explicitly, prevent accidental duplicate processing where relevant, and stop or route the item for review when a required step fails. For credentials, use the supported secure configuration rather than placing secrets directly in the content.

Expected output:
The final result should directly satisfy the "Portrait of a woman in a yellow raincoat under a streetlamp. Sharp eyes, soft background bokeh, film still look. No watermark. 3:4." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Food editorial

Scenario:
A realistic runway workflow is being prepared for Use Runway Text to Video Generation using runway. The starting requirement is: Overhead photo of a citrus salad on stoneware. Natural daylight. Fresh condensation on fruit. No utensils crossing oddly. No text. 1:1.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Overhead photo of a citrus salad on stoneware. Natural daylight. Fresh condensation on fruit. No utensils crossing oddly. No text. 1:1." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Inputs:
Use the actual source material required for this task, together with the intended audience, destination, format, and quality requirements. Specify relevant files, text, URLs, structured data, reference assets, dimensions, language, tone, timing, model or generation settings, credentials, field mappings, or integration values when they apply. Keep secrets out of the example and use the product's supported credential or configuration mechanism.

Workflow:
1. Start with one representative input that contains the important characteristics of the real workload.
2. Configure runway specifically for the requested task and make the important settings explicit.
3. Run the first pass and inspect the result against the objective.
4. Correct only the settings or source material responsible for a failed requirement instead of changing everything at once.
5. Validate the intermediate result before passing it to the next step.
6. When the result meets the requirements, save the successful configuration so the same process can be repeated consistently.
7. If this is a multi-step workflow, verify each handoff and keep a clear fallback or review path for failures.

Requirements:
The example must use supported functionality only. Do not invent product features, pricing, limits, integrations, model names, API behavior, or unavailable settings. Preserve important source data and formatting. Validate required fields before processing, handle empty or invalid input explicitly, prevent accidental duplicate processing where relevant, and stop or route the item for review when a required step fails. For credentials, use the supported secure configuration rather than placing secrets directly in the content.

Expected output:
The final result should directly satisfy the "Overhead photo of a citrus salad on stoneware. Natural daylight. Fresh condensation on fruit. No utensils crossing oddly. No text. 1:1." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Interior design board

Scenario:
A realistic runway workflow is being prepared for Use Runway Text to Video Generation using runway. The starting requirement is: Modern living room with oak floors and linen sofa. Soft morning light. Minimal decor. Architectural digest calm. No brand marks. 4:3.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Modern living room with oak floors and linen sofa. Soft morning light. Minimal decor. Architectural digest calm. No brand marks. 4:3." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Inputs:
Use the actual source material required for this task, together with the intended audience, destination, format, and quality requirements. Specify relevant files, text, URLs, structured data, reference assets, dimensions, language, tone, timing, model or generation settings, credentials, field mappings, or integration values when they apply. Keep secrets out of the example and use the product's supported credential or configuration mechanism.

Workflow:
1. Start with one representative input that contains the important characteristics of the real workload.
2. Configure runway specifically for the requested task and make the important settings explicit.
3. Run the first pass and inspect the result against the objective.
4. Correct only the settings or source material responsible for a failed requirement instead of changing everything at once.
5. Validate the intermediate result before passing it to the next step.
6. When the result meets the requirements, save the successful configuration so the same process can be repeated consistently.
7. If this is a multi-step workflow, verify each handoff and keep a clear fallback or review path for failures.

Requirements:
The example must use supported functionality only. Do not invent product features, pricing, limits, integrations, model names, API behavior, or unavailable settings. Preserve important source data and formatting. Validate required fields before processing, handle empty or invalid input explicitly, prevent accidental duplicate processing where relevant, and stop or route the item for review when a required step fails. For credentials, use the supported secure configuration rather than placing secrets directly in the content.

Expected output:
The final result should directly satisfy the "Modern living room with oak floors and linen sofa. Soft morning light. Minimal decor. Architectural digest calm. No brand marks. 4:3." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

App mock device

Scenario:
A realistic runway workflow is being prepared for Use Runway Text to Video Generation using runway. The starting requirement is: Smartphone on desk showing a blank soft gradient screen. Top down. Clean desk props only. Space for UI overlay later. No readable UI. 9:16.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Smartphone on desk showing a blank soft gradient screen. Top down. Clean desk props only. Space for UI overlay later. No readable UI. 9:16." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Inputs:
Use the actual source material required for this task, together with the intended audience, destination, format, and quality requirements. Specify relevant files, text, URLs, structured data, reference assets, dimensions, language, tone, timing, model or generation settings, credentials, field mappings, or integration values when they apply. Keep secrets out of the example and use the product's supported credential or configuration mechanism.

Workflow:
1. Start with one representative input that contains the important characteristics of the real workload.
2. Configure runway specifically for the requested task and make the important settings explicit.
3. Run the first pass and inspect the result against the objective.
4. Correct only the settings or source material responsible for a failed requirement instead of changing everything at once.
5. Validate the intermediate result before passing it to the next step.
6. When the result meets the requirements, save the successful configuration so the same process can be repeated consistently.
7. If this is a multi-step workflow, verify each handoff and keep a clear fallback or review path for failures.

Requirements:
The example must use supported functionality only. Do not invent product features, pricing, limits, integrations, model names, API behavior, or unavailable settings. Preserve important source data and formatting. Validate required fields before processing, handle empty or invalid input explicitly, prevent accidental duplicate processing where relevant, and stop or route the item for review when a required step fails. For credentials, use the supported secure configuration rather than placing secrets directly in the content.

Expected output:
The final result should directly satisfy the "Smartphone on desk showing a blank soft gradient screen. Top down. Clean desk props only. Space for UI overlay later. No readable UI. 9:16." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Abstract brand texture

Scenario:
A realistic runway workflow is being prepared for Use Runway Text to Video Generation using runway. The starting requirement is: Soft gradient mesh of seafoam and sand. Subtle grain. No shapes that look like letters. Suitable as motion background. 16:9.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Soft gradient mesh of seafoam and sand. Subtle grain. No shapes that look like letters. Suitable as motion background. 16:9." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Inputs:
Use the actual source material required for this task, together with the intended audience, destination, format, and quality requirements. Specify relevant files, text, URLs, structured data, reference assets, dimensions, language, tone, timing, model or generation settings, credentials, field mappings, or integration values when they apply. Keep secrets out of the example and use the product's supported credential or configuration mechanism.

Workflow:
1. Start with one representative input that contains the important characteristics of the real workload.
2. Configure runway specifically for the requested task and make the important settings explicit.
3. Run the first pass and inspect the result against the objective.
4. Correct only the settings or source material responsible for a failed requirement instead of changing everything at once.
5. Validate the intermediate result before passing it to the next step.
6. When the result meets the requirements, save the successful configuration so the same process can be repeated consistently.
7. If this is a multi-step workflow, verify each handoff and keep a clear fallback or review path for failures.

Requirements:
The example must use supported functionality only. Do not invent product features, pricing, limits, integrations, model names, API behavior, or unavailable settings. Preserve important source data and formatting. Validate required fields before processing, handle empty or invalid input explicitly, prevent accidental duplicate processing where relevant, and stop or route the item for review when a required step fails. For credentials, use the supported secure configuration rather than placing secrets directly in the content.

Expected output:
The final result should directly satisfy the "Soft gradient mesh of seafoam and sand. Subtle grain. No shapes that look like letters. Suitable as motion background. 16:9." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Kids book plate

Scenario:
A realistic runway workflow is being prepared for Use Runway Text to Video Generation using runway. The starting requirement is: Watercolor meadow with a red kite in the sky. Simple shapes, friendly color. Plenty of sky space. No text. 4:3.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Watercolor meadow with a red kite in the sky. Simple shapes, friendly color. Plenty of sky space. No text. 4:3." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Inputs:
Use the actual source material required for this task, together with the intended audience, destination, format, and quality requirements. Specify relevant files, text, URLs, structured data, reference assets, dimensions, language, tone, timing, model or generation settings, credentials, field mappings, or integration values when they apply. Keep secrets out of the example and use the product's supported credential or configuration mechanism.

Workflow:
1. Start with one representative input that contains the important characteristics of the real workload.
2. Configure runway specifically for the requested task and make the important settings explicit.
3. Run the first pass and inspect the result against the objective.
4. Correct only the settings or source material responsible for a failed requirement instead of changing everything at once.
5. Validate the intermediate result before passing it to the next step.
6. When the result meets the requirements, save the successful configuration so the same process can be repeated consistently.
7. If this is a multi-step workflow, verify each handoff and keep a clear fallback or review path for failures.

Requirements:
The example must use supported functionality only. Do not invent product features, pricing, limits, integrations, model names, API behavior, or unavailable settings. Preserve important source data and formatting. Validate required fields before processing, handle empty or invalid input explicitly, prevent accidental duplicate processing where relevant, and stop or route the item for review when a required step fails. For credentials, use the supported secure configuration rather than placing secrets directly in the content.

Expected output:
The final result should directly satisfy the "Watercolor meadow with a red kite in the sky. Simple shapes, friendly color. Plenty of sky space. No text. 4:3." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

More prompts

Scenario:
A realistic runway workflow is being prepared for Use Runway Text to Video Generation using runway. The starting requirement is: Prompt: jewelry macro Macro of a gold ring with a clear stone on black velvet. Specular control, sharp facets, no brand engraving. 1:1.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Prompt: jewelry macro Macro of a gold ring with a clear stone on black velvet. Specular control, sharp facets, no brand engraving. 1:1." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Inputs:
Use the actual source material required for this task, together with the intended audience, destination, format, and quality requirements. Specify relevant files, text, URLs, structured data, reference assets, dimensions, language, tone, timing, model or generation settings, credentials, field mappings, or integration values when they apply. Keep secrets out of the example and use the product's supported credential or configuration mechanism.

Workflow:
1. Start with one representative input that contains the important characteristics of the real workload.
2. Configure runway specifically for the requested task and make the important settings explicit.
3. Run the first pass and inspect the result against the objective.
4. Correct only the settings or source material responsible for a failed requirement instead of changing everything at once.
5. Validate the intermediate result before passing it to the next step.
6. When the result meets the requirements, save the successful configuration so the same process can be repeated consistently.
7. If this is a multi-step workflow, verify each handoff and keep a clear fallback or review path for failures.

Requirements:
The example must use supported functionality only. Do not invent product features, pricing, limits, integrations, model names, API behavior, or unavailable settings. Preserve important source data and formatting. Validate required fields before processing, handle empty or invalid input explicitly, prevent accidental duplicate processing where relevant, and stop or route the item for review when a required step fails. For credentials, use the supported secure configuration rather than placing secrets directly in the content.

Expected output:
The final result should directly satisfy the "Prompt: jewelry macro Macro of a gold ring with a clear stone on black velvet. Specular control, sharp facets, no brand engraving. 1:1." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.
Scenario:
A realistic runway workflow is being prepared for Use Runway Text to Video Generation using runway. The starting requirement is: Prompt: sneakers three quarter White sneakers on seamless gray. Three quarter angle. Soft shadow. Studio catalog look. No logos reinvented. 4:5.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Prompt: sneakers three quarter White sneakers on seamless gray. Three quarter angle. Soft shadow. Studio catalog look. No logos reinvented. 4:5." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Inputs:
Use the actual source material required for this task, together with the intended audience, destination, format, and quality requirements. Specify relevant files, text, URLs, structured data, reference assets, dimensions, language, tone, timing, model or generation settings, credentials, field mappings, or integration values when they apply. Keep secrets out of the example and use the product's supported credential or configuration mechanism.

Workflow:
1. Start with one representative input that contains the important characteristics of the real workload.
2. Configure runway specifically for the requested task and make the important settings explicit.
3. Run the first pass and inspect the result against the objective.
4. Correct only the settings or source material responsible for a failed requirement instead of changing everything at once.
5. Validate the intermediate result before passing it to the next step.
6. When the result meets the requirements, save the successful configuration so the same process can be repeated consistently.
7. If this is a multi-step workflow, verify each handoff and keep a clear fallback or review path for failures.

Requirements:
The example must use supported functionality only. Do not invent product features, pricing, limits, integrations, model names, API behavior, or unavailable settings. Preserve important source data and formatting. Validate required fields before processing, handle empty or invalid input explicitly, prevent accidental duplicate processing where relevant, and stop or route the item for review when a required step fails. For credentials, use the supported secure configuration rather than placing secrets directly in the content.

Expected output:
The final result should directly satisfy the "Prompt: sneakers three quarter White sneakers on seamless gray. Three quarter angle. Soft shadow. Studio catalog look. No logos reinvented. 4:5." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.
Scenario:
A realistic runway workflow is being prepared for Use Runway Text to Video Generation using runway. The starting requirement is: Prompt: city dawn aerial Aerial still of a coastal city at dawn. Soft haze, long shadows, calm sea. Photoreal. No aircraft. 16:9.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Prompt: city dawn aerial Aerial still of a coastal city at dawn. Soft haze, long shadows, calm sea. Photoreal. No aircraft. 16:9." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Inputs:
Use the actual source material required for this task, together with the intended audience, destination, format, and quality requirements. Specify relevant files, text, URLs, structured data, reference assets, dimensions, language, tone, timing, model or generation settings, credentials, field mappings, or integration values when they apply. Keep secrets out of the example and use the product's supported credential or configuration mechanism.

Workflow:
1. Start with one representative input that contains the important characteristics of the real workload.
2. Configure runway specifically for the requested task and make the important settings explicit.
3. Run the first pass and inspect the result against the objective.
4. Correct only the settings or source material responsible for a failed requirement instead of changing everything at once.
5. Validate the intermediate result before passing it to the next step.
6. When the result meets the requirements, save the successful configuration so the same process can be repeated consistently.
7. If this is a multi-step workflow, verify each handoff and keep a clear fallback or review path for failures.

Requirements:
The example must use supported functionality only. Do not invent product features, pricing, limits, integrations, model names, API behavior, or unavailable settings. Preserve important source data and formatting. Validate required fields before processing, handle empty or invalid input explicitly, prevent accidental duplicate processing where relevant, and stop or route the item for review when a required step fails. For credentials, use the supported secure configuration rather than placing secrets directly in the content.

Expected output:
The final result should directly satisfy the "Prompt: city dawn aerial Aerial still of a coastal city at dawn. Soft haze, long shadows, calm sea. Photoreal. No aircraft. 16:9." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.
Scenario:
A realistic runway workflow is being prepared for Use Runway Text to Video Generation using runway. The starting requirement is: Prompt: image to image restyle [upload product photo] Keep product shape and label area blank. Restyle lighting to soft daylight. No new objects.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Prompt: image to image restyle [upload product photo] Keep product shape and label area blank. Restyle lighting to soft daylight. No new objects." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Inputs:
Use the actual source material required for this task, together with the intended audience, destination, format, and quality requirements. Specify relevant files, text, URLs, structured data, reference assets, dimensions, language, tone, timing, model or generation settings, credentials, field mappings, or integration values when they apply. Keep secrets out of the example and use the product's supported credential or configuration mechanism.

Workflow:
1. Start with one representative input that contains the important characteristics of the real workload.
2. Configure runway specifically for the requested task and make the important settings explicit.
3. Run the first pass and inspect the result against the objective.
4. Correct only the settings or source material responsible for a failed requirement instead of changing everything at once.
5. Validate the intermediate result before passing it to the next step.
6. When the result meets the requirements, save the successful configuration so the same process can be repeated consistently.
7. If this is a multi-step workflow, verify each handoff and keep a clear fallback or review path for failures.

Requirements:
The example must use supported functionality only. Do not invent product features, pricing, limits, integrations, model names, API behavior, or unavailable settings. Preserve important source data and formatting. Validate required fields before processing, handle empty or invalid input explicitly, prevent accidental duplicate processing where relevant, and stop or route the item for review when a required step fails. For credentials, use the supported secure configuration rather than placing secrets directly in the content.

Expected output:
The final result should directly satisfy the "Prompt: image to image restyle [upload product photo] Keep product shape and label area blank. Restyle lighting to soft daylight. No new objects." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.
Scenario:
A realistic runway workflow is being prepared for Use Runway Text to Video Generation using runway. The starting requirement is: Prompt: turbo draft then final Draft on Gen-4 Image Turbo. Final on Gen-4 Image at 1080p if detail holds for video.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Prompt: turbo draft then final Draft on Gen-4 Image Turbo. Final on Gen-4 Image at 1080p if detail holds for video." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Inputs:
Use the actual source material required for this task, together with the intended audience, destination, format, and quality requirements. Specify relevant files, text, URLs, structured data, reference assets, dimensions, language, tone, timing, model or generation settings, credentials, field mappings, or integration values when they apply. Keep secrets out of the example and use the product's supported credential or configuration mechanism.

Workflow:
1. Start with one representative input that contains the important characteristics of the real workload.
2. Configure runway specifically for the requested task and make the important settings explicit.
3. Run the first pass and inspect the result against the objective.
4. Correct only the settings or source material responsible for a failed requirement instead of changing everything at once.
5. Validate the intermediate result before passing it to the next step.
6. When the result meets the requirements, save the successful configuration so the same process can be repeated consistently.
7. If this is a multi-step workflow, verify each handoff and keep a clear fallback or review path for failures.

Requirements:
The example must use supported functionality only. Do not invent product features, pricing, limits, integrations, model names, API behavior, or unavailable settings. Preserve important source data and formatting. Validate required fields before processing, handle empty or invalid input explicitly, prevent accidental duplicate processing where relevant, and stop or route the item for review when a required step fails. For credentials, use the supported secure configuration rather than placing secrets directly in the content.

Expected output:
The final result should directly satisfy the "Prompt: turbo draft then final Draft on Gen-4 Image Turbo. Final on Gen-4 Image at 1080p if detail holds for video." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Tips

  • Match still ratio to later video ratio
  • Prefer simpler detail when the still will be animated
  • Use Turbo for exploration when listed costs fit your budget
  • Spell required text carefully or forbid text
  • Confirm Free plan watermark behavior before client delivery
  • Share credits intentionally between stills and video

Verification notes

Image credit rates come from Runway academy model listings and can change. Plan prices and Free plan limits are documented on runwayml.com/pricing and Free plan help. Do not assume a still model is available on Free without checking for upgrade prompts.

Keep a short shot list beside your Runway session. Note model, duration, aspect ratio, and the one motion change you will try next. That habit saves credits when you iterate.

When a generation pauses or a plan limit appears, confirm your plan and remaining credits in the dashboard instead of guessing. Official Free plan help notes watermarks and a one time credit deposit.

Treat every clip as a draft until you review subject identity, flicker, and unwanted text. Export only after a full playback, not a frozen thumbnail.

If you collaborate, store winning prompts on a shared page with the seed when available. Reuse the prompt skeleton and change one variable at a time.

Match delivery early. A 9:16 social cut is harder to rescue from a 16:9 master than starting in the correct ratio.

Separate exploration from finals. Draft on lower cost models when they fit the mode, then spend Gen-4.5 credits once motion and framing are locked.

For client work, keep a verification note: no invented logos, no trademarked characters, and no claims the footage cannot support.

Close each session by archiving the best still or last frame for the next shot. Continuity across clips beats regenerating from memory.

Keep a short shot list beside your Runway session. Note model, duration, aspect ratio, and the one motion change you will try next. That habit saves credits when you iterate.

When a generation pauses or a plan limit appears, confirm your plan and remaining credits in the dashboard instead of guessing. Official Free plan help notes watermarks and a one time credit deposit.

Treat every clip as a draft until you review subject identity, flicker, and unwanted text. Export only after a full playback, not a frozen thumbnail.

If you collaborate, store winning prompts on a shared page with the seed when available. Reuse the prompt skeleton and change one variable at a time.

Match delivery early. A 9:16 social cut is harder to rescue from a 16:9 master than starting in the correct ratio.

Separate exploration from finals. Draft on lower cost models when they fit the mode, then spend Gen-4.5 credits once motion and framing are locked.

For client work, keep a verification note: no invented logos, no trademarked characters, and no claims the footage cannot support.

Close each session by archiving the best still or last frame for the next shot. Continuity across clips beats regenerating from memory.

Keep a short shot list beside your Runway session. Note model, duration, aspect ratio, and the one motion change you will try next. That habit saves credits when you iterate.

When a generation pauses or a plan limit appears, confirm your plan and remaining credits in the dashboard instead of guessing. Official Free plan help notes watermarks and a one time credit deposit.

Treat every clip as a draft until you review subject identity, flicker, and unwanted text. Export only after a full playback, not a frozen thumbnail.

If you collaborate, store winning prompts on a shared page with the seed when available. Reuse the prompt skeleton and change one variable at a time.

Match delivery early. A 9:16 social cut is harder to rescue from a 16:9 master than starting in the correct ratio.

Common mistakes

  • Generating video and image in conflicting aspect ratios
  • Expecting perfect logos or trademarked characters without control
  • Skipping still review before Image to Video spend
  • Over detailing textures that flicker when animated
  • Using watermarked Free outputs in paid client work
  • Writing multi scene prompts for a single still

Related Runway articles: /blog/how-to-use-runway-image-to-video-generation, /blog/how-to-use-runway-keyframes-and-animate-frames, and /blog/how-to-use-runway-text-to-video-generation. Return to /explore/runway for the broader guide set.

Related articles