Runway Ci Integration

Overview

Implementation patterns for Runway ci integration — AI video generation platform.

Prerequisites

• Completed runway-install-auth setup

Instructions

Step 1: SDK Pattern

from runwayml import RunwayML

client = RunwayML()

task = client.image_to_video.create(
    model='gen3a_turbo',
    prompt_text='A serene lake at dawn, mist rising, birds flying',
    duration=5,
)
result = task.wait_for_task_output()
if result.status == 'SUCCEEDED':
    print(f"Video: {result.output[0]}")

Output

• Runway integration for ci integration

Error Handling

Resources

• Runway API Documentation
• Python SDK

Next Steps

See related Runway skills for more workflows.

Runway Common Errors

Overview

Implementation patterns for Runway common errors — AI video generation platform.

Prerequisites

• Completed runway-install-auth setup

Instructions

Step 1: SDK Pattern

from runwayml import RunwayML

client = RunwayML()

task = client.image_to_video.create(
    model='gen3a_turbo',
    prompt_text='A serene lake at dawn, mist rising, birds flying',
    duration=5,
)
result = task.wait_for_task_output()
if result.status == 'SUCCEEDED':
    print(f"Video: {result.output[0]}")

Output

• Runway integration for common errors

Error Handling

Resources

• Runway API Documentation
• Python SDK

Next Steps

See related Runway skills for more workflows.

Runway Core Workflow A

Overview

Advanced text-to-video generation: prompt engineering, model selection, parameter tuning, and batch generation.

Prerequisites

• Completed runway-hello-world

Instructions

Step 1: Model Selection

from runwayml import RunwayML
client = RunwayML()

# Available models:
# gen3a_turbo   — Fast, lower cost, good quality
# gen4_turbo    — Latest model, highest quality

task = client.image_to_video.create(
    model='gen4_turbo',
    prompt_text='A futuristic cityscape at night with flying cars and neon signs, cyberpunk aesthetic',
    duration=10,
    ratio='16:9',
)
result = task.wait_for_task_output()

Step 2: Prompt Engineering Tips

# Structure: Subject + Action + Setting + Style + Camera
prompts = [
    # Good: specific, visual, stylistic
    "A red fox walking through a snowy forest, soft winter light, documentary style, tracking shot",

    # Good: detailed motion and camera
    "Waves of golden wheat swaying in the wind, drone flyover, warm sunset, cinematic grain",

    # Bad: too abstract
    # "Something beautiful happening" — too vague
]

Step 3: Batch Generation

import asyncio

prompts = [
    "A butterfly emerging from a cocoon, macro lens, time-lapse, studio lighting",
    "Rain falling on a Tokyo street at night, reflections, neon, dolly zoom",
    "A chef preparing sushi in a traditional kitchen, close-up, warm lighting",
]

tasks = []
for prompt in prompts:
    task = client.image_to_video.create(
        model='gen3a_turbo',
        prompt_text=prompt,
        duration=5,
    )
    tasks.append(task)
    print(f"Queued: {task.id}")

# Wait for all
for task in tasks:
    result = task.wait_for_task_output()
    status = "OK" if result.status == "SUCCEEDED" else "FAILED"
    print(f"  {task.id}: {status}")

Step 4: Output Format Options

task = client.image_to_video.create(
    model='gen3a_turbo',
    prompt_text='Abstract paint mixing in slow motion, vibrant colors, black background',
    duration=5,
    ratio='9:16',      # Vertical for mobile/TikTok
    # ratio='16:9',    # Landscape for YouTube
    # ratio='1:1',     # Square for Instagram
)

Output

• Videos generated with optimal model selection
• Prompt engineering best practices applied
• Batch generation for multiple videos
• Output in various aspect ratios

Error Handling

Runway Core Workflow B

Overview

Image-to-video and video-to-video generation: animate still images and transform existing videos.

Prerequisites

• Completed runway-core-workflow-a

Instructions

Step 1: Image-to-Video

from runwayml import RunwayML
client = RunwayML()

# Animate a still image
task = client.image_to_video.create(
    model='gen3a_turbo',
    prompt_image='https://your-cdn.com/landscape.jpg',  # URL to source image
    prompt_text='Camera slowly pans right revealing mountains, gentle wind in trees',
    duration=5,
)
result = task.wait_for_task_output()
print(f"Animated video: {result.output[0]}")

Step 2: Image-to-Video with Data URI

import base64

# Load local image as data URI
with open('photo.jpg', 'rb') as f:
    image_data = base64.b64encode(f.read()).decode()
    data_uri = f"data:image/jpeg;base64,{image_data}"

task = client.image_to_video.create(
    model='gen3a_turbo',
    prompt_image=data_uri,
    prompt_text='Subtle motion, gentle camera push in, atmospheric lighting',
    duration=5,
)

Step 3: Video-to-Video (Style Transfer)

# Transform an existing video with a new style
task = client.video_to_video.create(
    model='gen3a_turbo',
    prompt_video='https://your-cdn.com/input-video.mp4',
    prompt_text='Transform to watercolor painting style, soft colors, artistic brushstrokes',
)
result = task.wait_for_task_output()
print(f"Styled video: {result.output[0]}")

Step 4: Image Specifications

Supported formats: JPEG, PNG, WebP
Supported resolutions:
  - Gen-3 Alpha Turbo: 1280x768 or 768x1280
  - Input images are automatically resized
Max file size: 16MB (URL), varies for data URI

Output

• Still images animated with motion prompts
• Local images encoded as data URIs
• Videos restyled with text prompts
• Proper image format handling

Error Handling

Resources

• Runway API Reference
• Input P…

Runway Cost Tuning

Overview

Implementation patterns for Runway cost tuning — AI video generation platform.

Prerequisites

• Completed runway-install-auth setup

Instructions

Step 1: SDK Pattern

from runwayml import RunwayML

client = RunwayML()

task = client.image_to_video.create(
    model='gen3a_turbo',
    prompt_text='A serene lake at dawn, mist rising, birds flying',
    duration=5,
)
result = task.wait_for_task_output()
if result.status == 'SUCCEEDED':
    print(f"Video: {result.output[0]}")

Output

• Runway integration for cost tuning

Error Handling

Resources

• Runway API Documentation
• Python SDK

Next Steps

See related Runway skills for more workflows.

Runway Debug Bundle

Overview

Implementation patterns for Runway debug bundle — AI video generation platform.

Prerequisites

• Completed runway-install-auth setup

Instructions

Step 1: SDK Pattern

from runwayml import RunwayML

client = RunwayML()

task = client.image_to_video.create(
    model='gen3a_turbo',
    prompt_text='A serene lake at dawn, mist rising, birds flying',
    duration=5,
)
result = task.wait_for_task_output()
if result.status == 'SUCCEEDED':
    print(f"Video: {result.output[0]}")

Output

• Runway integration for debug bundle

Error Handling

Resources

• Runway API Documentation
• Python SDK

Next Steps

See related Runway skills for more workflows.

Runway Deploy Integration

Overview

Implementation patterns for Runway deploy integration — AI video generation platform.

Prerequisites

• Completed runway-install-auth setup

Instructions

Step 1: SDK Pattern

from runwayml import RunwayML

client = RunwayML()

task = client.image_to_video.create(
    model='gen3a_turbo',
    prompt_text='A serene lake at dawn, mist rising, birds flying',
    duration=5,
)
result = task.wait_for_task_output()
if result.status == 'SUCCEEDED':
    print(f"Video: {result.output[0]}")

Output

• Runway integration for deploy integration

Error Handling

Resources

• Runway API Documentation
• Python SDK

Next Steps

See related Runway skills for more workflows.

Runway Hello World

Overview

Generate your first AI video from a text prompt using Runway's Gen-3 Alpha model.

Prerequisites

• Completed runway-install-auth
• API credits available in your Runway account

Instructions

Step 1: Text-to-Video Generation

from runwayml import RunwayML

client = RunwayML()

# Create a text-to-video generation task
task = client.image_to_video.create(
    model='gen3a_turbo',
    prompt_text='A golden retriever running through a field of sunflowers, cinematic lighting, slow motion',
    duration=5,  # 5 or 10 seconds
    ratio='16:9',  # 16:9 or 9:16
)
print(f"Task created: {task.id}")

Step 2: Poll for Completion

import time

# The SDK has a built-in helper for polling
task_result = client.tasks.retrieve(task.id)

# Or poll manually
while task_result.status not in ('SUCCEEDED', 'FAILED'):
    time.sleep(5)
    task_result = client.tasks.retrieve(task.id)
    print(f"  Status: {task_result.status}")

if task_result.status == 'SUCCEEDED':
    print(f"Video URL: {task_result.output[0]}")
else:
    print(f"Failed: {task_result.failure}")

Step 3: Download the Video

import urllib.request

if task_result.status == 'SUCCEEDED':
    video_url = task_result.output[0]
    urllib.request.urlretrieve(video_url, 'output.mp4')
    print("Video saved to output.mp4")

Step 4: Using the Built-in Wait Helper

# Simpler approach — SDK polls automatically
task = client.image_to_video.create(
    model='gen3a_turbo',
    prompt_text='Ocean waves crashing on rocky cliffs at sunset, aerial view',
    duration=5,
)
# Wait for completion (default timeout: 10 minutes)
result = task.wait_for_task_output()
print(f"Video: {result.output[0]}")

Output

• Video generation task created
• Task polled until completion
• Generated video URL retrieved
• Video downloaded to local file

Error Handling

Resources

• …

Runway Install Auth

Overview

Install the Runway ML SDK and configure API key authentication for AI video generation.

Prerequisites

• Runway account at runwayml.com
• API key from the Runway Developer Portal (dev.runwayml.com)
• Python 3.9+ or Node.js 18+

Instructions

Step 1: Install SDK

set -euo pipefail
# Python
pip install runwayml

# Node.js
npm install @runwayml/sdk

Step 2: Configure Environment

# .env
RUNWAYML_API_SECRET=key_xxxxxxxxxxxxxxxxxxxxxxxx

Step 3: Verify Connection (Python)

from runwayml import RunwayML

client = RunwayML()  # Reads RUNWAYML_API_SECRET from env

# The client is ready — no explicit auth call needed
# SDK auto-authenticates on first API call
print("RunwayML client initialized")

Step 4: Verify Connection (Node.js)

import RunwayML from '@runwayml/sdk';

const runway = new RunwayML();  // Reads RUNWAYML_API_SECRET from env
console.log('RunwayML client initialized');

Output

• runwayml SDK installed
• API key configured via environment variable
• Client ready for video generation

Error Handling

Resources

• Runway API Documentation
• Python SDK
• API Getting Started

Next Steps

Generate your first video: runway-hello-world

Runway Local Dev Loop

Overview

Implementation patterns for Runway local dev loop — AI video generation platform.

Prerequisites

• Completed runway-install-auth setup

Instructions

Step 1: SDK Pattern

from runwayml import RunwayML

client = RunwayML()

task = client.image_to_video.create(
    model='gen3a_turbo',
    prompt_text='A serene lake at dawn, mist rising, birds flying',
    duration=5,
)
result = task.wait_for_task_output()
if result.status == 'SUCCEEDED':
    print(f"Video: {result.output[0]}")

Output

• Runway integration for local dev loop

Error Handling

Resources

• Runway API Documentation
• Python SDK

Next Steps

See related Runway skills for more workflows.

Runway Performance Tuning

Overview

Implementation patterns for Runway performance tuning — AI video generation platform.

Prerequisites

• Completed runway-install-auth setup

Instructions

Step 1: SDK Pattern

from runwayml import RunwayML

client = RunwayML()

task = client.image_to_video.create(
    model='gen3a_turbo',
    prompt_text='A serene lake at dawn, mist rising, birds flying',
    duration=5,
)
result = task.wait_for_task_output()
if result.status == 'SUCCEEDED':
    print(f"Video: {result.output[0]}")

Output

• Runway integration for performance tuning

Error Handling

Resources

• Runway API Documentation
• Python SDK

Next Steps

See related Runway skills for more workflows.

Runway Prod Checklist

Overview

Implementation patterns for Runway prod checklist — AI video generation platform.

Prerequisites

• Completed runway-install-auth setup

Instructions

Step 1: SDK Pattern

from runwayml import RunwayML

client = RunwayML()

task = client.image_to_video.create(
    model='gen3a_turbo',
    prompt_text='A serene lake at dawn, mist rising, birds flying',
    duration=5,
)
result = task.wait_for_task_output()
if result.status == 'SUCCEEDED':
    print(f"Video: {result.output[0]}")

Output

• Runway integration for prod checklist

Error Handling

Resources

• Runway API Documentation
• Python SDK

Next Steps

See related Runway skills for more workflows.

Runway Rate Limits

Overview

Implementation patterns for Runway rate limits — AI video generation platform.

Prerequisites

• Completed runway-install-auth setup

Instructions

Step 1: SDK Pattern

from runwayml import RunwayML

client = RunwayML()

task = client.image_to_video.create(
    model='gen3a_turbo',
    prompt_text='A serene lake at dawn, mist rising, birds flying',
    duration=5,
)
result = task.wait_for_task_output()
if result.status == 'SUCCEEDED':
    print(f"Video: {result.output[0]}")

Output

• Runway integration for rate limits

Error Handling

Resources

• Runway API Documentation
• Python SDK

Next Steps

See related Runway skills for more workflows.

Runway Reference Architecture

Overview

Implementation patterns for Runway reference architecture — AI video generation platform.

Prerequisites

• Completed runway-install-auth setup

Instructions

Step 1: SDK Pattern

from runwayml import RunwayML

client = RunwayML()

task = client.image_to_video.create(
    model='gen3a_turbo',
    prompt_text='A serene lake at dawn, mist rising, birds flying',
    duration=5,
)
result = task.wait_for_task_output()
if result.status == 'SUCCEEDED':
    print(f"Video: {result.output[0]}")

Output

• Runway integration for reference architecture

Error Handling

Resources

• Runway API Documentation
• Python SDK

Next Steps

See related Runway skills for more workflows.

Runway Sdk Patterns

Overview

Implementation patterns for Runway sdk patterns — AI video generation platform.

Prerequisites

• Completed runway-install-auth setup

Instructions

Step 1: SDK Pattern

from runwayml import RunwayML

client = RunwayML()

task = client.image_to_video.create(
    model='gen3a_turbo',
    prompt_text='A serene lake at dawn, mist rising, birds flying',
    duration=5,
)
result = task.wait_for_task_output()
if result.status == 'SUCCEEDED':
    print(f"Video: {result.output[0]}")

Output

• Runway integration for sdk patterns

Error Handling

Resources

• Runway API Documentation
• Python SDK

Next Steps

See related Runway skills for more workflows.

Runway Security Basics

Overview

Implementation patterns for Runway security basics — AI video generation platform.

Prerequisites

• Completed runway-install-auth setup

Instructions

Step 1: SDK Pattern

from runwayml import RunwayML

client = RunwayML()

task = client.image_to_video.create(
    model='gen3a_turbo',
    prompt_text='A serene lake at dawn, mist rising, birds flying',
    duration=5,
)
result = task.wait_for_task_output()
if result.status == 'SUCCEEDED':
    print(f"Video: {result.output[0]}")

Output

• Runway integration for security basics

Error Handling

Resources

• Runway API Documentation
• Python SDK

Next Steps

See related Runway skills for more workflows.

Runway Upgrade Migration

Overview

Implementation patterns for Runway upgrade migration — AI video generation platform.

Prerequisites

• Completed runway-install-auth setup

Instructions

Step 1: SDK Pattern

from runwayml import RunwayML

client = RunwayML()

task = client.image_to_video.create(
    model='gen3a_turbo',
    prompt_text='A serene lake at dawn, mist rising, birds flying',
    duration=5,
)
result = task.wait_for_task_output()
if result.status == 'SUCCEEDED':
    print(f"Video: {result.output[0]}")

Output

• Runway integration for upgrade migration

Error Handling

Resources

• Runway API Documentation
• Python SDK

Next Steps

See related Runway skills for more workflows.

Runway Webhooks Events

Overview

Implementation patterns for Runway webhooks events — AI video generation platform.

Prerequisites

• Completed runway-install-auth setup

Instructions

Step 1: SDK Pattern

from runwayml import RunwayML

client = RunwayML()

task = client.image_to_video.create(
    model='gen3a_turbo',
    prompt_text='A serene lake at dawn, mist rising, birds flying',
    duration=5,
)
result = task.wait_for_task_output()
if result.status == 'SUCCEEDED':
    print(f"Video: {result.output[0]}")

Output

• Runway integration for webhooks events

Error Handling

Resources

• Runway API Documentation
• Python SDK

Next Steps

See related Runway skills for more workflows.