Para un rol recurrente, mantén estables estos campos:

• Nombre
• Rango de edad y presentación
• Silueta del cabello
• Colores distintivos de la vestimenta
• Un accesorio distintivo
• Imagen de referencia principal
• Referencias opcionales de perfil y tres cuartos

En este ejemplo, el rol es un mensajero con cabello corto y oscuro, un impermeable amarillo y un bolso mensajero rojo. Esos detalles son lo suficientemente compactos como para repetirlos y lo suficientemente distintivos como para auditarlos.

Paso 1: Preparar el entorno del servidor

Usa Node.js 20 o una versión más reciente para que fetch, FormData y Blob estén disponibles. Mantén la clave en una variable de entorno solo del servidor.

export LLAMAGEN_API_KEY="your_server_side_key"

No expongas esta clave en un bundle de navegador, aplicación móvil, repositorio público o solicitud del lado del cliente. Si tu producto tiene un frontend, envía el resumen del usuario a tu propio backend y deja que ese backend llame a LlamaGen.AI.

El flujo de trabajo tiene cuatro operaciones de red:

Paso 2: Ejecutar el inicio rápido de TypeScript

Guarda lo siguiente como comic-quickstart.ts, coloca una imagen del personaje en ./courier-reference.png y ejecútalo desde tu entorno de servidor.

import { basename } from "node:path";
import { readFile } from "node:fs/promises";
import { randomUUID } from "node:crypto";

const API_BASE = "https://api.llamagen.ai";
const API_KEY = process.env.LLAMAGEN_API_KEY;

if (!API_KEY) {
  throw new Error("Set LLAMAGEN_API_KEY before running this script.");
}

type UploadResponse = {
  code?: number;
  fileUrl: string;
};

type Usage = {
  total_comics?: number;
  redraw_panels?: number;
  amount?: number;
};

type Generation = {
  id: string;
  status: "LOADING" | "PROCESSED" | "FAILED" | "CANCELLED" | string;
  usage?: Usage;
  comics?: Array<{
    page?: number;
    panels?: Array<{
      panel?: number;
      image?: string;
      assetUrl?: string;
      caption?: string;
    }>;
  }>;
  error?: unknown;
};

async function api<T>(path: string, init: RequestInit = {}): Promise<T> {
  const response = await fetch(`${API_BASE}${path}`, {
    ...init,
    headers: {
      Authorization: `Bearer ${API_KEY}`,
      ...init.headers,
    },
  });

  const text = await response.text();
  const body = text ? JSON.parse(text) : null;

  if (!response.ok) {
    throw new Error(
      `Comic API ${response.status}: ${JSON.stringify(body)}`,
    );
  }

  return body as T;
}

async function uploadReference(filePath: string) {
  const bytes = await readFile(filePath);
  const form = new FormData();
  form.set("file", new Blob([bytes]), basename(filePath));

  return api<UploadResponse>("/v1/comics/upload", {
    method: "POST",
    body: form,
  });
}

async function waitForGeneration(
  generationId: string,
  timeoutMs = 10 * 60_000,
) {
  const startedAt = Date.now();

  while (Date.now() - startedAt < timeoutMs) {
    const job = await api<Generation>(
      `/v1/comics/generations/${generationId}`,
    );

    console.log(
      JSON.stringify({
        generationId,
        status: job.status,
        elapsedMs: Date.now() - startedAt,
        usage: job.usage,
      }),
    );

    if (job.status === "PROCESSED") return job;

    if (job.status === "FAILED" || job.status === "CANCELLED") {
      throw new Error(
        `Generation ended as ${job.status}: ${JSON.stringify(job.error)}`,
      );
    }

    await new Promise((resolve) => setTimeout(resolve, 4_000));
  }

  throw new Error(`Generation ${generationId} timed out.`);
}

async function main() {
  const startedAt = Date.now();

  try {
    const reference = await uploadReference("./courier-reference.png");

    const created = await api<Generation>("/v1/comics/generations", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Idempotency-Key": randomUUID(),
      },
      body: JSON.stringify({
        prompt: [
          "Create one four-panel comic page in a restrained cinematic manga style.",
          "Panel 1: Ren enters a rain-soaked station and notices a golden key.",
          "Panel 2: Close view as Ren lifts the key and studies it.",
          "Panel 3: Ren runs toward an old locked service door.",
          "Panel 4: Ren opens the door and warm light spills into the station.",
          "Keep the same face, haircut, yellow jacket, and red messenger bag.",
          "Leave clean space for later lettering.",
        ].join("\n"),
        preset: "japanese_manga",
        size: "1024x1024",
        fixPanelNum: 4,
        language: "en",
        comicRoles: [
          {
            name: "Ren",
            age: 22,
            gender: "male",
            dress: "yellow rain jacket, black trousers, red messenger bag",
            image: reference.fileUrl,
          },
        ],
      }),
    });

    const firstPass = await waitForGeneration(created.id);
    console.log("first_pass_complete", {
      id: firstPass.id,
      elapsedMs: Date.now() - startedAt,
      usage: firstPass.usage,
      pages: firstPass.comics?.length ?? 0,
    });

    // Example review result: panel 3 lost the red bag.
    const repairQueued = await api<Generation>(
      `/v1/comics/generations/${created.id}`,
      {
        method: "PATCH",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          page: 0,
          panel: 2,
          panelPrompt:
            "Ren runs toward the service door. Preserve his exact face, short dark hair, yellow rain jacket, and visible red messenger bag.",
          images: [reference.fileUrl],
        }),
      },
    );

    console.log("repair_queued", {
      id: repairQueued.id,
      usage: repairQueued.usage,
    });

    const repaired = await waitForGeneration(created.id);
    console.log("workflow_complete", {
      id: repaired.id,
      totalElapsedMs: Date.now() - startedAt,
      finalStatus: repaired.status,
    });
  } catch (error) {
    console.error("comic_workflow_failed", {
      elapsedMs: Date.now() - startedAt,
      message: error instanceof Error ? error.message : String(error),
    });
    process.exitCode = 1;
  }
}

await main();

Ejecútalo con:

npx tsx comic-quickstart.ts

El ejemplo registra intencionalmente objetos estructurados. En producción, envía los mismos campos a tu sistema de observabilidad e incluye tu propio identificador de solicitud o proyecto.

Paso 3: Revisar los cuatro paneles como si fueran un conjunto de datos

No apruebes una página porque se vea atractiva en tamaño miniatura. Audita cada panel según el bloqueo del personaje:

Trata esto como control de calidad legible por máquina si estás construyendo un pipeline más grande. Almacena una razón de aprobado/reprobado por panel, no solo una aprobación general de la página.

Paso 4: Repara un panel, no toda la página

El prompt de reparación más rápido nombra tanto la nueva acción como los elementos que no pueden cambiar.

Reparación del panel 3:
Ren corre hacia la puerta de servicio.
Conserva su rostro exacto, cabello corto y oscuro, impermeable amarillo,
y el bolso mensajero rojo visible.
Mantén la estación lluviosa y el movimiento de izquierda a derecha.

Los índices de panel son de base cero, así que el tercer panel visible es panel: 2. El endpoint de actualización puede aceptar panelPrompt, images de referencia o una caption de reemplazo.

Esto importa a nivel operativo. Volver a generar los cuatro paneles puede introducir tres nuevos riesgos de continuidad mientras se corrige uno anterior. La reparación dirigida reduce la superficie de revisión.

Lista de verificación para endurecimiento en producción

Antes de lanzar la integración, agrega estos controles:

1. Usa una clave de idempotencia única para cada generación prevista.
2. Almacena el ID de generación inmediatamente después de la creación.
3. Consulta con un intervalo fijo o backoff y aplica un timeout.
4. Registra estado, tiempo transcurrido, uso y payloads de fallo.
5. Conserva las URLs de referencia cargadas con el registro del proyecto.
6. Valida que el número de paneles devuelto coincida con la solicitud.
7. Revisa por separado identidad, vestuario, accesorios, continuidad de escena y espacio para rotulación.
8. Repara solo el panel afectado siempre que sea posible.
9. Nunca expongas la clave de API al código del lado del cliente.
10. Lee el uso y los precios actuales desde la respuesta de la API y la documentación en lugar de codificar suposiciones antiguas.

Para secuencias más largas, cambia de fixPanelNum a pagination.totalPages y pagination.panelsPerPage. No envíes ambos modos en una sola solicitud de creación.

Cuándo usar la API en lugar del editor

Usa la API de Cómics cuando los cómics se generen dentro de tu propio producto, trabajo por lotes, herramienta educativa, pipeline de publicación o flujo de trabajo del cliente.

Usa el editor visual cuando un creador quiera explorar la historia de forma interactiva, comparar alternativas o dirigir artísticamente cada página a mano. Muchos equipos usan ambos: la API crea y registra la primera pasada repetible, mientras que el editor maneja revisiones excepcionales.

Si la estructura de tu historia todavía está cambiando, planifícala antes de crear paneles terminados. La siguiente guía, ¿Storyboard primero o paneles de cómic primero?, muestra cómo medir la diferencia de retrabajo.

Preguntas frecuentes

¿Puedo generar exactamente cuatro paneles?

Sí. Envía fixPanelNum: 4 para una solicitud de una sola página con cuatro paneles. Para varias páginas, usa el objeto pagination en su lugar.

¿Cómo mantengo la consistencia de un personaje?

Sube una imagen de referencia limpia, pasa su fileUrl devuelto en comicRoles[].image, mantén estables el nombre del rol y la descripción del vestuario, y audita cada panel devuelto antes de continuar la secuencia.

¿Puedo regenerar solo un panel malo?

Sí. Envía una solicitud PATCH con los índices de página y panel de base cero más un nuevo panelPrompt, imágenes de referencia opcionales o caption.

¿Debo reintentar una solicitud de creación fallida con la misma clave de idempotencia?

Usa el comportamiento de idempotencia documentado por LlamaGen.AI para que los reintentos de red no creen trabajo duplicado accidentalmente. Usa una clave nueva solo cuando realmente quieras una nueva generación.

¿Este ejemplo muestra números de benchmark reales?

No. Muestra la instrumentación necesaria para capturar tus números reales. Publica latencia, uso y tasas de fallo solo después de ejecutar repetidamente la misma entrada en tu propia cuenta y registrar las condiciones.

Fuentes y divulgación editorial

• Documentación de la API de Cómics de LlamaGen.AI, verificada el 10 de octubre de 2026
• API de Cómics de LlamaGen.AI
• Cookbook de consistencia de la API de modelos de Meta, consultado por el principio más amplio de anclar una serie de imágenes a referencias visuales estables

Escrito por Jay y revisado técnicamente contra el contrato del endpoint en vivo por el equipo de contenido de LlamaGen.AI. El comportamiento del producto puede cambiar; la documentación enlazada es la fuente de verdad.

¿Listo para crear el flujo de trabajo? Abre la API de Cómics de LlamaGen.AI, crea una clave del lado del servidor y ejecuta el inicio rápido con tu propia referencia de personaje.

© 2026 LlamaGen.Ai Todos los derechos reservados

Blogs anteriores

Cómic en movimiento vs animática: ¿Cuál deberías hacer?

Usa los mismos seis paneles de cómic terminados para comparar los flujos de trabajo de animática y c

Jay

10 de octubre de 2026

¿Storyboard primero o generar primero los paneles del cómic?

Una prueba transparente del costo de retrabajo compara los flujos de trabajo de cómic con IA de stor

Jay

10 de octubre de 2026

Inicio rápido de la API de Cómics: Genera cuatro paneles consistentes

Crea un flujo de trabajo de producción listo para TypeScript con la API de Cómics que sube una refer

Jay

10 de octubre de 2026

Generador de cómics con IA gratis vs. terminar de verdad un cómic

Una prueba práctica de generadores de cómics con IA gratis frente a un flujo de trabajo de guion a l

Jay

21 de septiembre de 2026