Runway API: Integre Geração de Vídeo em Pipelines Automatizados

A Runway oferece uma API que permite integrar geração de vídeo em pipelines automatizados — desde scripts simples até sistemas de produção de conteúdo em escala.

Configuração da API

1. Obtenha sua API key

Acesse app.runwayml.com → Settings → API Keys → Create Key.

2. Instale o SDK

# Node.js (SDK oficial)
npm install @runwayml/sdk

# Python
pip install runwayml

Gerando um vídeo (Text to Video)

import Runway from "@runwayml/sdk";

const client = new Runway({ apiKey: process.env.RUNWAY_API_KEY });

async function generateVideo(prompt: string): Promise<string> {
  // 1. Cria a task de geração
  const task = await client.imageToVideo.create({
    model: "gen3a_turbo",
    promptText: prompt,
    duration: 5,
    ratio: "1280:720",
  });

  // 2. Faz polling até a task completar
  let result = await client.tasks.retrieve(task.id);
  while (!["SUCCEEDED", "FAILED"].includes(result.status)) {
    await new Promise(resolve => setTimeout(resolve, 5000)); // aguarda 5s
    result = await client.tasks.retrieve(task.id);
  }

  if (result.status === "FAILED") {
    throw new Error(`Geração falhou: ${result.failure}`);
  }

  return result.output[0]; // URL do vídeo gerado
}

Image to Video via API

import { readFileSync } from "fs";

async function animateImage(imagePath: string, motionPrompt: string) {
  // Converter imagem para base64
  const imageData = readFileSync(imagePath);
  const base64Image = `data:image/jpeg;base64,${imageData.toString("base64")}`;

  const task = await client.imageToVideo.create({
    model: "gen3a_turbo",
    promptImage: base64Image,
    promptText: motionPrompt,
    duration: 5,
    ratio: "1280:720",
  });

  // ... polling igual ao exemplo acima
}

Pipeline de produção de conteúdo

Exemplo real: sistema que gera vídeos de produto automaticamente a partir de fotos:

import { createClient } from "@supabase/supabase-js";
import Runway from "@runwayml/sdk";

const supabase = createClient(SUPABASE_URL, SUPABASE_SERVICE_KEY);
const runway = new Runway({ apiKey: RUNWAY_API_KEY });

async function processProductImages() {
  // Busca produtos que precisam de vídeo
  const { data: products } = await supabase
    .from("products")
    .select("*")
    .eq("video_generated", false)
    .limit(5); // processa em lotes de 5

  for (const product of products) {
    try {
      const prompt = `${product.name} product video.
The product rotates slowly on a clean white surface.
Professional studio lighting. High-end commercial quality.`;

      const task = await runway.imageToVideo.create({
        model: "gen3a_turbo",
        promptImage: product.image_url,
        promptText: prompt,
        duration: 5,
      });

      // Salva o task_id para polling posterior
      await supabase
        .from("products")
        .update({ runway_task_id: task.id, video_status: "processing" })
        .eq("id", product.id);

      console.log(`Task criada para produto ${product.name}: ${task.id}`);
    } catch (error) {
      console.error(`Erro ao processar ${product.name}:`, error);
    }
  }
}

Webhook para processamento assíncrono

Em vez de polling ativo, use webhooks:

// Endpoint que recebe notificação do Runway quando o vídeo fica pronto
app.post("/runway-webhook", async (req, res) => {
  const { id, status, output } = req.body;

  if (status === "SUCCEEDED") {
    const videoUrl = output[0];
    
    // Atualiza o banco com a URL do vídeo
    await supabase
      .from("products")
      .update({ video_url: videoUrl, video_generated: true })
      .eq("runway_task_id", id);
  }

  res.status(200).send("OK");
});

Custos e limites da API

Um vídeo de 10 segundos custa: $0.50 (turbo) a $0.80 (standard).

Boas práticas

• Cache de resultados: salve as URLs dos vídeos gerados para não regenerar
• Retry logic: a API pode falhar esporadicamente — implemente retry com backoff
• Timeout: vídeos levam 2-5 minutos para gerar; não bloqueie threads esperando
• Rate limiting: a API tem limites por minuto — gerencie filas de jobs

Com a Runway API, você pode escalar produção de vídeo que antes exigia horas de trabalho humano em um processo completamente automatizado.