Un plan práctico para construir una app generadora de imágenes con IA: el bucle de peticiones, un stack que se puede lanzar en una semana, cómo conectar una API de imágenes con código de Node que funciona y un presupuesto mensual que muestra lo que cuesta realmente cada generación antes del lanzamiento.
Una app generadora de imágenes con IA parece un producto grande desde fuera y uno pequeño por dentro. Una persona escribe una frase, tu servidor se la pasa a un modelo, unos segundos después vuelve una imagen, y la guardas en un lugar donde la persona pueda encontrarla de nuevo. Todo lo demás son detalles de acabado: cuentas, una galería, créditos, una forma de frenar los abusos. La parte que más sorprende a quien la construye no es el código. Es la factura. El costo por imagen, multiplicado por las veces que la gente pulsa el botón, decide si la app gana dinero o lo pierde.
Este artículo propone un stack que puedes construir en una semana, muestra cómo encajan las llamadas a la API con código que funciona contra la API de PicassoIA, y hace cuentas honestas del costo mensual para que puedas poner precio al producto antes del día del lanzamiento.
Quitando la marca, cada app generadora de imágenes hace el mismo trabajo: convierte una petición de texto en un archivo, y lo hace sin que la persona se quede mirando una pantalla congelada. Cuando ves la app como un bucle de peticiones con una galería adjunta, la construcción se vuelve mucho más pequeña.
succeeded, copia el archivo a tu propio almacenamiento.
Cada función que añadas en el futuro se apoya en esos cinco pasos. Los créditos se conectan al paso 2. Las galerías se conectan al paso 5. La generación de video es el mismo bucle con un paso 4 más lento.
Elige la versión más pequeña por la que alguien pagaría. Cada tipo de entrada extra añade trabajo en el back end.
| Forma del producto | Lo que hacen los usuarios | Trabajo adicional para ti |
|---|---|---|
| Solo caja de prompt | Escribir una frase y obtener una imagen | Cola, galería, cuota |
| Prompt más edición | Subir una foto y modificarla | Límites de subida, comprobación de archivos, un modelo de edición como PicassoIA Image Editor Pro |
| Imágenes más video corto | Animar un resultado en un clip | Trabajos más largos, archivos más grandes, un modelo de video como PicassoIA Video |
💡 Empieza con una caja de texto y un botón. Las funciones que añadas después cuestan menos que las que tengas que quitar cuando los usuarios ya dependan de ellas.
Aquí ganan las herramientas aburridas. El modelo hace la parte difícil, así que tu stack solo necesita ser fiable, barato de ejecutar y fácil de cambiar cuando aparezca un modelo mejor el mes que viene.
Un framework de React como Next.js te da una página de prompts, una galería y rutas de servidor en un solo proyecto. Si la mayoría de tus usuarios estarán en el teléfono, lanza primero una aplicación web progresiva y pasa a React Native o Flutter solo cuando necesites un acceso más profundo a la cámara o a los archivos. La pantalla en sí es sencilla: una caja de texto, un selector de tamaño, un botón y una cuadrícula.
Usa Node o Python, lo que tu equipo ya escriba. La pieza que no debes saltarte es una cola de trabajos. La generación de imágenes es lenta comparada con una petición web normal, y las API de imágenes limitan cuántos trabajos se ejecutan a la vez. Una cola (Redis con BullMQ, o Celery en Python) te permite aceptar cada clic al instante y alimentar la API a un ritmo seguro.
Mantén una sola tabla generations en Postgres con estas columnas: id, user_id, prompt, model, status, cost_usd, image_url, created_at. Esa tabla alimenta la galería, la comprobación de cuota y tus informes de costos.
Copia cada imagen terminada en tu propio bucket detrás de una CDN. No dependas de que la URL temporal de un proveedor siga activa para siempre. Guarda el original más una miniatura WebP más pequeña para que la galería cargue rápido en dispositivos móviles.
| Capa | Opción sencilla | Cambia de opción cuando |
|---|---|---|
| Front end | Next.js o React simple | Necesites funciones nativas del dispositivo |
| Capa de API | Node (Fastify) o FastAPI | El tráfico necesite workers separados |
| Cola | Redis con BullMQ o Celery | Llames a más de un proveedor |
| Base de datos | Postgres | Los informes se vuelvan pesados |
| Almacenamiento | Bucket compatible con S3 más CDN | Los usuarios estén en muchas regiones |
| Inicio de sesión | Enlaces por correo u OAuth | Vendes cuentas de equipo |
Puedes alquilar un modelo por llamada o ejecutar tus propias GPU. Para un primer lanzamiento, la respuesta casi siempre es la primera.
Una API alojada significa sin drivers, sin trabajo de escalado, muchos modelos tras una misma interfaz, y pagas por imagen. Una GPU alquilada significa una factura fija por hora y una larga lista de tareas: pesos del modelo, límites de memoria, actualizaciones, colas y caídas a las 3 de la madrugada.
Las cuentas deciden. Supongamos que una GPU alquilada cuesta $1,50 por hora y genera 120 imágenes por hora. Si nunca está inactiva, cada imagen cuesta unos $0,0125. Si solo está ocupada el 20% del tiempo, en realidad generas 24 imágenes por hora y cada una cuesta $0,0625. Son cifras de ejemplo, pero la tendencia general se mantiene: autoalojar solo compensa con un tráfico alto y constante.
La colección de modelos de texto a imagen de PicassoIA enumera más de 200 modelos, lo que es útil porque ningún modelo es el mejor en todo. Elige uno por defecto y mantén una o dos alternativas detrás de un ajuste, para poder cambiar cuando cambien la calidad, la velocidad o el precio.
| Modelo | Pruébalo para |
|---|---|
| PicassoIA Image | Un valor por defecto general, disponible a través de la API de PicassoIA |
| P Image | Resultados fotográficos rápidos a bajo costo |
| FLUX Schnell | Borradores rápidos y vistas previas |
| FLUX 2 Pro | Imágenes finales de mayor calidad |
| Seedream 5 Pro | Escenas detalladas que vale la pena comparar con tu modelo por defecto |
| GPT Image 2 | Prompts con instrucciones específicas o texto corto en la imagen |
| Imagen 4 Fast | Una alternativa rápida con un aspecto distinto |
La mayoría de la gente escribe prompts como "un perro en una playa". Un modelo de lenguaje pequeño puede ampliar eso en un prompt más rico antes de la llamada a la imagen, y cuesta una fracción de centavo. Claude Sonnet 5 y Gemini 3.5 Flash encajan en esta tarea, y GPT 5 Structured devuelve JSON limpio cuando necesitas que la reescritura se divida en campos como sujeto, iluminación y objetivo.
La misma familia de modelos puede hacer un segundo trabajo: revisar los prompts antes de que lleguen al modelo de imágenes. Más sobre eso abajo.
PicassoIA ofrece una API REST al estilo de Replicate, así que el flujo es el del bucle de peticiones: crear una predicción, consultarla y obtener el resultado. Los endpoints y límites de abajo provienen de la página pública de la API, y esa página es el lugar donde confirmar los detalles antes de lanzar.
Antes de escribir código, prueba el modelo a mano. Lleva diez minutos y ahorra días de conjeturas.
💡 Si tu app edita fotos, repite la misma prueba con PicassoIA Image Editor Pro usando subidas reales, no muestras de stock.
La URL base es https://api.picassoia.com/v1. Cada petición lleva una cabecera Authorization: Bearer con un secreto que empieza por pia_sk_. Lo creas en la página de API de tu cuenta, y una cuenta puede tener como máximo dos, así que rota uno cada vez. Nunca pongas ese secreto en código de navegador o de móvil. Debe estar en tu servidor, en una variable de entorno. Los requisitos del plan y los precios de acceso a la API aparecen en esa página y pueden cambiar, así que léelos antes de elaborar un presupuesto a partir de ellos.
Se puede acceder a cuatro modelos mediante la API:
| Modelo | Salida |
|---|---|
| PicassoIA Image | Imágenes a partir de texto |
| PicassoIA Image Editor Pro | Imágenes editadas |
| PicassoIA Video | Video a partir de texto o de una imagen |
| Seedance 2.5 Lite | Video con audio |
Planifica con estos límites:
| Límite | Valor |
|---|---|
| Predicciones simultáneas | 5 por cuenta, compartidas entre todos los secretos y conexiones MCP |
| Cuerpo de la petición | 10 MB |
| Longitud del prompt | 4.000 caracteres |
| Tiempo máximo del trabajo | 3 horas |
El techo de cinco trabajos marca toda tu arquitectura, por eso la cola de antes no es opcional.
Los endpoints son POST /v1/models/{owner}/{name}/predictions para iniciar un trabajo, GET /v1/predictions/{id} para leerlo, POST /v1/predictions/{id}/cancel para detenerlo y GET /v1/predictions para listar los trabajos recientes. Este es todo el bucle en Node 18 o posterior:
const BASE = "https://api.picassoia.com/v1";
const headers = {
Authorization: `Bearer ${process.env.PICASSOIA_TOKEN}`,
"Content-Type": "application/json",
};
async function call(url, options) {
const res = await fetch(url, { headers, ...options });
if (!res.ok) throw new Error(`HTTP ${res.status}`);
return res.json();
}
export async function generate(prompt) {
const created = await call(
`${BASE}/models/picassoia/picassoia-image/predictions`,
{
method: "POST",
body: JSON.stringify({ input: { prompt, aspect_ratio: "16:9" } }),
}
);
let job = created;
while (!["succeeded", "failed", "canceled"].includes(job.status)) {
await new Promise((r) => setTimeout(r, 2000));
job = await call(`${BASE}/predictions/${created.id}`);
}
if (job.status !== "succeeded") throw new Error(job.error ?? job.status);
return Array.isArray(job.output) ? job.output[0] : job.output;
}
Dos notas sobre ese código. Primero, los nombres de los campos de entrada cambian de un modelo a otro, así que lee la página de cada modelo y haz coincidir los nombres exactamente. Segundo, en producción guardas created.id en tu base de datos antes de que empiece la consulta, para que un reinicio del servidor nunca pierda un trabajo pagado.
Los costos se dividen en dos grupos: costos variables que crecen con cada clic, y costos fijos que no cambian. Los costos variables son los peligrosos.
La fórmula principal es corta:
Costo mensual = usuarios × generaciones por usuario × costo por imagen + costos fijos
La palabra que hay que vigilar es generaciones. La gente pulsa el botón varias veces por cada imagen que se queda, así que mide las generaciones por imagen conservada desde el primer día de tu beta y presupuesta con esa cifra, no con el número de imágenes guardadas.
Tomemos 2.000 usuarios activos que hacen 20 generaciones al mes cada uno. Eso son 40.000 imágenes. Los precios de abajo son supuestos de planificación, así que sustituye por la tarifa actual del modelo que elijas. Los costos fijos de alojamiento, base de datos y almacenamiento se fijan en $100 al mes para este tamaño.
| Escenario | Precio supuesto por imagen | Factura de imágenes | Con $100 fijos | Resultado con $2.700 de ingresos |
|---|---|---|---|---|
| Modelo de borradores rápidos | $0,01 | $400 | $500 | +$2.200 |
| Modelo de gama media | $0,04 | $1.600 | $1.700 | +$1.000 |
| Modelo premium | $0,08 | $3.200 | $3.300 | -$600 |
La cifra de ingresos supone que 300 de los 2.000 usuarios pagan $9 al mes. La fila premium pierde dinero aunque la app parezca sana, porque los usuarios gratuitos también generan imágenes. Tres soluciones funcionan bien juntas: limitar el nivel gratuito, vender créditos ajustados al precio real de cada modelo y enviar las peticiones de borrador al modelo barato, reservando el premium para los render finales.
Costos que la gente olvida:
La velocidad y la seguridad son baratas de añadir al principio y dolorosas de añadir después del lanzamiento.
Con cinco predicciones simultáneas por cuenta de PicassoIA, una cola decide lo fluida que se comporta tu app. Supón que una imagen tarda unos 10 segundos. Cinco trabajos a la vez dan unas 30 imágenes por minuto, o 1.800 por hora. Las 40.000 imágenes del presupuesto de arriba promedian unas 55 por hora. Incluso una hora punta a cinco veces el promedio, unas 280 imágenes, cabe con holgura.
Reglas que mantienen sana la cola:
Revisa el prompt antes de que llegue al modelo de imágenes. Un clasificador de seguridad como Llama Guard 4 12B lee el texto y marca las categorías que elijas bloquear. Es barato, rápido y mantiene tu cuenta fuera de problemas.
Si los usuarios pueden subir fotos, revisa también las subidas. Registra cada rechazo con el id del usuario y el motivo, porque los patrones en esos registros te dicen quién está poniendo a prueba tus límites.
Dos mejoras que se amortizan solas:
Un equipo pequeño puede lanzar una beta privada en siete días si el alcance se mantiene ajustado.
| Día | Tarea |
|---|---|
| 1 | Elige un modelo por defecto y prueba 20 prompts realistas a mano |
| 2 | Construye la ruta del back end que crea y consulta una predicción |
| 3 | Añade almacenamiento, miniaturas y la página de la galería |
| 4 | Añade inicio de sesión, una cuota diaria y registro de costos por generación |
| 5 | Añade moderación de prompts y límites de peticiones por usuario |
| 6 | Añade créditos o un enlace de pago sencillo |
| 7 | Invita a 20 testers y revisa los registros juntos |
Los errores que más tiempo cuestan: construir un pipeline de modelo propio antes de comprobar que alguien quiere el producto, escribir un nombre de modelo fijo en veinte lugares y olvidar registrar el costo de cada generación. Corrige lo último el día cuatro y cada decisión posterior será más fácil, porque verás qué prompts, usuarios y modelos impulsan la factura.
La forma más rápida de juzgar un modelo es usarlo. Abre PicassoIA Image, escribe el prompt que escribiría un usuario real y mira lo que devuelve. Luego prueba el mismo prompt en dos o tres modelos más de la lista completa de modelos y compara calidad, velocidad y estilo lado a lado.
Cuando los resultados se vean bien, lee la página de la API de PicassoIA, crea tu primer secreto y ejecuta el fragmento de Node de arriba. Un prompt, una predicción, una imagen guardada en tu propio almacenamiento: esa es la app entera en miniatura, y todo lo que venga después es escalar. Empieza a experimentar hoy, y la primera imagen que cree tu propio código te dirá más que cualquier plan.
Elige tu idioma
