Cómo usar la API Seedream 4.5 en PoYo: Guía completa para desarrolladores

La API Seedream 4.5, respaldada por la tecnología de generación de imágenes ultra 4K de ByteDance, ofrece creación de contenido visual profesional por 5 créditos por generación, unos 0,025 $ USD en PoYo. Esta guía te muestra cómo implementar lógica avanzada de iluminación, precisión de texto profesional y calidad fotográfica comercial utilizando la API de PoYo.

Resumen del modelo Seedream 4.5

Seedream 4.5 es un modelo de IA para generación de imágenes de última generación desarrollado por ByteDance, que ofrece resolución ultra 4K con calidad profesional. En PoYo.ai, este modelo destaca por:

• Resolución Ultra 4K: Genera imágenes nítidas y detalladas de hasta 4096x4096 píxeles
• Precisión profesional de texto: Representación avanzada de texto con tipografía perfecta
• Lógica inteligente de iluminación: Cálculos de luz y sombra sofisticados
• Calidad fotográfica comercial: Composición de estudio y precisión cromática
• Varios formatos de aspecto: Compatible con 1:1, 4:3, 3:4, 16:9, 9:16, 3:2, 2:3, 21:9

Página de detalles del modelo

Visita la página de modelo Seedream 4.5 API para:

• Zona de pruebas interactiva: Prueba la API directamente desde tu navegador
• Ejemplos en vivo: Consulta generaciones y prompts de muestra
• Documentación de la API: Parámetros y referencias completas
• Información de precios: Tarifas actuales (5 créditos = 0,025 $ por imagen)
• Benchmarks de rendimiento: Comparativas de velocidad y calidad

Primeros pasos con la API Seedream 4.5

Paso 1: Crea tu cuenta de PoYo

Para empezar, crea tu cuenta de PoYo y consigue tus credenciales para la API:

1. Regístrate en PoYo.ai
2. Genera tu clave API en el panel de usuario
3. Añade créditos a tu cuenta (Seedream 4.5 cuesta 5 créditos por cada generación)
4. Explora el modelo en la página Seedream 4.5

Paso 2: Instala las dependencias necesarias

# Para Node.js/JavaScript
npm install axios

# Para Python
pip install requests

# Para cURL (no requiere instalación)

Generación básica de imagen a partir de texto

Implementación en JavaScript/Node.js

const axios = require('axios');

const generateImage = async (prompt, size = '16:9') => {
  try {
    const response = await axios.post(
      'https://api.poyo.ai/api/generate/submit',
      {
        model: 'seedream-4.5',
        callback_url: 'https://your-domain.com/callback', // Webhook opcional
        input: {
          prompt: prompt,
          size: size, // Opciones: '1:1', '4:3', '3:4', '16:9', '9:16', '3:2', '2:3', '21:9'
          n: 1
        }
      },
      {
        headers: {
          'Authorization': `Bearer YOUR_API_KEY`,
          'Content-Type': 'application/json'
        }
      }
    );

    console.log('Task ID:', response.data.data.task_id);
    console.log('Created:', response.data.data.created_time);
    return response.data.data;
  } catch (error) {
    console.error('Error generating image:', error.response?.data || error.message);
  }
};

// Ejemplo de uso con prompt de fotografía profesional de producto
generateImage('Professional commercial product photography of luxury watch with cinematic lighting and golden ratio composition', '16:9');

Implementación en Python

import requests
import json

def generate_image(prompt, api_key, size='16:9'):
    url = "https://api.poyo.ai/api/generate/submit"

    payload = {
        "model": "seedream-4.5",
        "callback_url": "https://your-domain.com/callback",  # Webhook opcional
        "input": {
            "prompt": prompt,
            "size": size,  # Opciones: '1:1', '4:3', '3:4', '16:9', '9:16', '3:2', '2:3', '21:9'
            "n": 1
        }
    }

    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }

    try:
        response = requests.post(url, json=payload, headers=headers)
        response.raise_for_status()

        result = response.json()['data']
        print(f"Task ID: {result['task_id']}")
        print(f"Created: {result['created_time']}")
        return result

    except requests.exceptions.RequestException as e:
        print(f"Error generating image: {e}")
        return None

# Ejemplo de uso con calidad ultra 4K
api_key = "YOUR_API_KEY"
result = generate_image("Ultra high-quality 4K commercial photography of modern architecture with perfect lighting", api_key, '21:9')

Implementación en cURL

curl -X POST "https://api.poyo.ai/api/generate/submit" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedream-4.5",
    "callback_url": "https://your-domain.com/callback",
    "input": {
      "prompt": "Professional e-commerce product photography with cinematic color grading and natural proportions",
      "size": "4:3",
      "n": 1
    }
  }'

Funcionalidades avanzadas de Seedream 4.5

1. Precisión de texto profesional

Seedream 4.5 destaca en la generación de texto nítido y tipografía perfecta a nivel comercial:

const generateTextRichImages = async () => {
  const textPrompts = [
    "Professional corporate signage with 'PoYo API' text in modern sans-serif font",
    "Technical diagram with precise mathematical equations and clear labels",
    "Branded marketing poster with sharp typography and commercial quality text"
  ];

  for (const prompt of textPrompts) {
    const result = await generateImage(prompt, '16:9');
    console.log(`Generated professional text image: ${prompt}`);
  }
};

// Genera imágenes con textos perfectamente renderizados
generateTextRichImages();

2. Lógica avanzada de iluminación

Aprovecha el motor de iluminación revolucionario de Seedream 4.5 para calidad fotográfica comercial:

def generate_commercial_photography(product_name, api_key):
    prompt = f"Professional commercial photography of {product_name} with cinematic color grading, realistic lighting, natural proportions, and strong 3D depth for e-commerce catalog"

    payload = {
        "model": "seedream-4.5",
        "input": {
            "prompt": prompt,
            "size": "1:1",  # Ideal para e-commerce
            "n": 1
        }
    }

    return generate_image_with_payload(payload, api_key)

# Genera fotos de productos con calidad comercial
products = ["luxury skincare bottle", "premium headphones", "artisan coffee package"]
for product in products:
    result = generate_commercial_photography(product, "YOUR_API_KEY")

3. Razonamiento avanzado de composición

Seedream 4.5 entiende términos y técnicas de composición fotográfica profesional:

const compositionPrompts = [
  "Professional portrait with golden ratio composition and background blur",
  "Landscape photography using rule of thirds with diagonal composition",
  "Commercial product shot with dramatic lighting and cinematic framing",
  "Architectural photography with leading lines and symmetrical balance"
];

const generateWithComposition = async (prompt, technique) => {
  const enhancedPrompt = `${prompt}, ${technique}, ultra 4K resolution, professional photography quality`;

  const response = await axios.post(
    'https://api.poyo.ai/api/generate/submit',
    {
      model: 'seedream-4.5',
      input: {
        prompt: enhancedPrompt,
        size: '16:9',
        n: 1
      }
    },
    {
      headers: {
        'Authorization': `Bearer YOUR_API_KEY`,
        'Content-Type': 'application/json'
      }
    }
  );

  return response.data.data;
};

4. Salida en resolución Ultra 4K

Genera imágenes en alta resolución listas para uso comercial:

def generate_4k_content(description, api_key, aspect_ratio='16:9'):
    prompt = f"Ultra high-resolution 4K quality {description}, professional commercial photography standards, enhanced visual refinement, print-ready quality"

    payload = {
        "model": "seedream-4.5",
        "input": {
            "prompt": prompt,
            "size": aspect_ratio,
            "n": 1
        }
    }

    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }

    response = requests.post("https://api.poyo.ai/api/generate/submit", json=payload, headers=headers)
    return response.json()['data']

# Genera imágenes 4K para diferentes usos
use_cases = [
    ("billboard advertisement design", "21:9"),
    ("magazine cover photography", "3:4"),
    ("desktop wallpaper", "16:9"),
    ("social media post", "1:1")
]

for description, size in use_cases:
    result = generate_4k_content(description, "YOUR_API_KEY", size)
    print(f"Generated 4K {description} in {size} format")

Edición de imágenes con Seedream 4.5

Transformación de imagen a imagen

const editImage = async (imageUrls, editPrompt, size = '16:9') => {
  try {
    const response = await axios.post(
      'https://api.poyo.ai/api/generate/submit',
      {
        model: 'seedream-4.5-edit',
        callback_url: 'https://your-domain.com/callback', // Opcional
        input: {
          prompt: editPrompt,
          image_urls: imageUrls, // Array de URLs de imágenes de referencia (máx. 5)
          size: size,
          n: 1
        }
      },
      {
        headers: {
          'Authorization': `Bearer YOUR_API_KEY`,
          'Content-Type': 'application/json'
        }
      }
    );

    return response.data.data;
  } catch (error) {
    console.error('Error editing image:', error.response?.data || error.message);
  }
};

// Ejemplo: Mejora una foto de producto con iluminación profesional
const result = await editImage(
  ['https://example.com/product-photo.jpg'],
  'Enhanced commercial photography with professional studio lighting, cinematic color grading, and ultra 4K quality',
  '1:1'
);

Comprobación del estado de la generación

Consulta manual del estado

const checkTaskStatus = async (taskId) => {
  try {
    const response = await axios.get(
      `https://api.poyo.ai/api/generate/status/${taskId}`,
      {
        headers: {
          'Authorization': `Bearer YOUR_API_KEY`
        }
      }
    );

    return response.data.data; // Devuelve los datos de la tarea
  } catch (error) {
    console.error('Error checking status:', error.message);
    return null;
  }
};

const pollForResult = async (taskId, maxAttempts = 30) => {
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    const taskData = await checkTaskStatus(taskId);

    if (!taskData) break;

    console.log(`Status: ${taskData.status}`);

    if (taskData.status === 'finished') {
      console.log('¡Imagen ultra 4K generada con éxito!');
      if (taskData.files && taskData.files.length > 0) {
        console.log('Image URL:', taskData.files[0].file_url);
        console.log('File type:', taskData.files[0].file_type);
      }
      return taskData;
    } else if (taskData.status === 'failed') {
      console.error('Generation failed:', taskData.error_message);
      return null;
    }

    // Estado 'processing'
    await new Promise(resolve => setTimeout(resolve, 3000)); // Espera 3 segundos
  }

  console.error('Se alcanzó el número máximo de intentos');
  return null;
};

// Ejemplo de workflow completo
const completeGeneration = async (prompt, size = '16:9') => {
  // 1. Enviar la solicitud de generación
  const generation = await generateImage(prompt, size);

  if (!generation) return null;

  // 2. Consultar el resultado
  const result = await pollForResult(generation.task_id);

  return result;
};

Comprobación de estado en Python

import time

def check_task_status(task_id, api_key):
    url = f"https://api.poyo.ai/api/generate/status/{task_id}"

    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }

    try:
        response = requests.get(url, headers=headers)
        response.raise_for_status()

        return response.json()['data']
    except requests.exceptions.RequestException as e:
        print(f"Error checking status: {e}")
        return None

def wait_for_completion(task_id, api_key, max_attempts=30):
    for attempt in range(max_attempts):
        task_data = check_task_status(task_id, api_key)

        if not task_data:
            break

        print(f"Status: {task_data['status']}")

        if task_data['status'] == 'finished':
            print("¡Imagen ultra 4K generada con éxito!")
            if task_data.get('files') and len(task_data['files']) > 0:
                print(f"Image URL: {task_data['files'][0]['file_url']}")
                print(f"File type: {task_data['files'][0]['file_type']}")
            return task_data
        elif task_data['status'] == 'failed':
            print(f"Generation failed: {task_data.get('error_message', 'Unknown error')}")
            return None

        time.sleep(3)  # Espera 3 segundos

    print("Se alcanzó el número máximo de intentos")
    return None

# Workflow completo
def complete_image_generation(prompt, api_key, size='16:9'):
    # 1. Enviar solicitud
    task_result = generate_image(prompt, api_key, size)

    if not task_result:
        return None

    # 2. Esperar a finalizar
    final_result = wait_for_completion(task_result['task_id'], api_key)

    return final_result

Gestión de errores y buenas prácticas

Gestión integral de errores

const robustImageGeneration = async (prompt, size = '16:9', retries = 3) => {
  for (let attempt = 0; attempt < retries; attempt++) {
    try {
      const response = await axios.post(
        'https://api.poyo.ai/api/generate/submit',
        {
          model: 'seedream-4.5',
          input: {
            prompt: prompt,
            size: size,
            n: 1
          }
        },
        {
          headers: {
            'Authorization': `Bearer YOUR_API_KEY`,
            'Content-Type': 'application/json'
          },
          timeout: 30000 // Timeout de 30 segundos
        }
      );

      return response.data.data;

    } catch (error) {
      if (error.response) {
        // Error devuelto por el servidor
        const status = error.response.status;
        const message = error.response.data?.message || 'Error desconocido';

        console.error(`API Error (${status}): ${message}`);

        // No reintentar ante ciertos errores
        if (status === 401 || status === 403) {
          throw new Error('Autenticación fallida. Revisa tu clave API.');
        }

        if (status === 400) {
          throw new Error(`Solicitud incorrecta: ${message}`);
        }

      } else if (error.request) {
        console.error('Error de red:', error.message);
      } else {
        console.error('Error en la llamada:', error.message);
      }

      // Si es el último intento, lanza el error
      if (attempt === retries - 1) {
        throw error;
      }

      // Espera progresiva antes de reintentar
      const delay = Math.pow(2, attempt) * 1000;
      console.log(`Reintentando en ${delay}ms... (Intento ${attempt + 1}/${retries})`);
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
};

Casos de uso comercial

Fotografía de producto para e-commerce

const generateProductPhotos = async (productName, variations = []) => {
  const basePrompt = `Professional e-commerce product photography of ${productName}`;

  const scenarios = [
    'with clean white background and studio lighting',
    'with lifestyle setting and natural lighting',
    'with dramatic shadows and commercial quality',
    'with 360-degree view perspective'
  ];

  const results = [];

  for (const scenario of scenarios) {
    const fullPrompt = `${basePrompt} ${scenario}, ultra 4K resolution, commercial photography standards`;

    try {
      const generation = await generateImage(fullPrompt, '1:1');
      const result = await pollForResult(generation.task_id);

      if (result) {
        results.push({
          scenario: scenario,
          imageUrl: result.files[0].file_url,
          taskId: result.task_id
        });
      }
    } catch (error) {
      console.error(`Failed to generate ${scenario}:`, error.message);
    }
  }

  return results;
};

// Genera fotos de productos para e-commerce
const productPhotos = await generateProductPhotos('luxury smartphone');

Marketing y publicidad

def generate_marketing_assets(campaign_theme, brand_colors="", sizes=['1:1', '16:9', '9:16']):
    assets = []

    for size in sizes:
        # Determinar formato según tamaño
        format_type = {
            '1:1': 'social media post',
            '16:9': 'banner advertisement',
            '9:16': 'mobile story format',
            '21:9': 'wide banner',
            '4:3': 'display advertisement'
        }.get(size, 'general format')

        prompt = f"Professional {format_type} design for {campaign_theme}, {brand_colors}, cinematic quality, commercial photography standards, ultra 4K resolution"

        try:
            result = generate_image(prompt, "YOUR_API_KEY", size)
            if result:
                final_result = wait_for_completion(result['task_id'], "YOUR_API_KEY")
                if final_result:
                    assets.append({
                        'format': format_type,
                        'size': size,
                        'image_url': final_result['files'][0]['file_url'],
                        'task_id': final_result['task_id']
                    })
        except Exception as e:
            print(f"Failed to generate {format_type}: {e}")

    return assets

# Genera materiales completos para campaña de marketing
campaign_assets = generate_marketing_assets(
    "luxury travel experience campaign",
    "gold and deep blue color scheme",
    ['1:1', '16:9', '9:16', '21:9']
)

Consejos para optimizar el rendimiento

1. Ingeniería de prompts para Seedream 4.5

• Utiliza terminología profesional: “commercial photography”, “cinematic lighting”, “ultra 4K”
• Especifica la composición: “golden ratio”, “rule of thirds”, “diagonal composition”
• Incluye directrices de calidad: “professional grade”, “commercial standards”, “print-ready”
• Aprovecha las funciones avanzadas: “enhanced visual refinement”, “advanced lighting logic”

// Estructura de prompt optimizada
const buildOptimizedPrompt = (subject, style, quality, composition) => {
  return `${subject}, ${style}, ${quality}, ${composition}, ultra 4K resolution, commercial photography standards, enhanced visual refinement`;
};

// Ejemplos
const prompts = [
  buildOptimizedPrompt(
    "luxury watch product photography",
    "professional studio lighting with cinematic color grading",
    "commercial grade quality",
    "golden ratio composition with background blur"
  ),
  buildOptimizedPrompt(
    "modern architecture visualization",
    "dramatic natural lighting with realistic shadows",
    "print-ready 4K quality",
    "diagonal composition with leading lines"
  )
];

2. Selección del formato de aspecto

Elige el formato de aspecto más adecuado para cada caso de uso:

const aspectRatioGuide = {
  '1:1': 'Publicaciones en redes sociales, fotos de perfil, imágenes de productos',
  '4:3': 'Pantallas tradicionales, presentaciones, fondos de escritorio',
  '3:4': 'Pantallas móviles, fotografía vertical, cubiertas de libros',
  '16:9': 'Miniaturas de vídeo, banners anchos, fotografía de paisaje',
  '9:16': 'Historias móviles, vídeos verticales, fondos para smartphone',
  '3:2': 'Fotografía clásica, medios impresos, marcos de fotos',
  '2:3': 'Impresión vertical, portadas de revistas, maquetación de libros',
  '21:9': 'Banners ultra pano, display de cine, panorámicas'
};

const selectOptimalRatio = (useCase) => {
  const ratioMap = {
    'social_media': '1:1',
    'youtube_thumbnail': '16:9',
    'instagram_story': '9:16',
    'website_banner': '21:9',
    'product_catalog': '1:1',
    'magazine_cover': '2:3',
    'landscape_photo': '3:2'
  };

  return ratioMap[useCase] || '16:9';
};

3. Procesamiento por lotes para flujos comerciales

class Seedream45Client {
  constructor(apiKey, options = {}) {
    this.apiKey = apiKey;
    this.baseURL = 'https://api.poyo.ai';
    this.concurrentRequests = options.concurrentRequests || 5;
  }

  async generateImageBatch(prompts, options = {}) {
    const { size = '16:9', maxRetries = 3 } = options;

    // Procesa por lotes para no saturar la API
    const batches = this.chunkArray(prompts, this.concurrentRequests);
    const allResults = [];

    for (const batch of batches) {
      const batchPromises = batch.map(prompt =>
        this.generateSingleImage(prompt, size, maxRetries)
      );

      try {
        const batchResults = await Promise.all(batchPromises);
        allResults.push(...batchResults.filter(result => result !== null));
      } catch (error) {
        console.error('Batch processing error:', error);
      }

      // Espera entre lotes para respetar los límites de la API
      await new Promise(resolve => setTimeout(resolve, 1000));
    }

    return allResults;
  }

  async generateSingleImage(prompt, size, maxRetries) {
    try {
      const generation = await this.submitGeneration(prompt, size);
      if (!generation) return null;

      const result = await this.waitForCompletion(generation.task_id);
      return result;
    } catch (error) {
      console.error(`Failed to generate image for prompt: ${prompt.substring(0, 50)}...`, error);
      return null;
    }
  }

  chunkArray(array, chunkSize) {
    const chunks = [];
    for (let i = 0; i < array.length; i += chunkSize) {
      chunks.push(array.slice(i, i + chunkSize));
    }
    return chunks;
  }
}

// Ejemplo de uso
const client = new Seedream45Client('YOUR_API_KEY', { concurrentRequests: 3 });

const commercialPrompts = [
  'Professional luxury car photography with cinematic lighting',
  'High-end fashion photography with commercial quality',
  'Premium food photography with perfect composition',
  'Corporate headshot with professional studio lighting'
];

const results = await client.generateImageBatch(commercialPrompts, {
  size: '4:3',
  maxRetries: 2
});

Aspectos clave para uso en producción

1. Gestión de claves API

// Configuración según entorno
const config = {
  apiKey: process.env.POYO_API_KEY,
  baseURL: process.env.POYO_API_URL || 'https://api.poyo.ai',
  timeout: parseInt(process.env.API_TIMEOUT) || 30000,
  retries: parseInt(process.env.API_RETRIES) || 3
};

// Validación de configuración
if (!config.apiKey) {
  throw new Error('La variable de entorno POYO_API_KEY es obligatoria');
}

2. Monitorización y logging

import logging
from datetime import datetime

# Configuración del logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class Seedream45Monitor:
    def __init__(self):
        self.generation_stats = {
            'total_requests': 0,
            'successful_generations': 0,
            'failed_generations': 0,
            'total_credits_used': 0
        }

    def log_generation_request(self, prompt, size, task_id):
        logger.info(f"Solicitud enviada - Tarea: {task_id}, Tamaño: {size}, Prompt: {prompt[:50]}...")
        self.generation_stats['total_requests'] += 1

    def log_generation_success(self, task_id, image_url):
        logger.info(f"Generación completada con éxito - Tarea: {task_id}, URL: {image_url}")
        self.generation_stats['successful_generations'] += 1
        self.generation_stats['total_credits_used'] += 5  # Cada generación Seedream 4.5 cuesta 5 créditos

    def log_generation_failure(self, task_id, error_message):
        logger.error(f"Error en la generación - Tarea: {task_id}, Error: {error_message}")
        self.generation_stats['failed_generations'] += 1

    def get_stats(self):
        success_rate = (self.generation_stats['successful_generations'] /
                       max(self.generation_stats['total_requests'], 1)) * 100

        return {
            **self.generation_stats,
            'success_rate': f"{success_rate:.2f}%",
            'average_cost': self.generation_stats['total_credits_used'] /
                          max(self.generation_stats['successful_generations'], 1)
        }

# Uso de la clase monitor
monitor = Seedream45Monitor()

def generate_with_monitoring(prompt, api_key, size='16:9'):
    try:
        # Enviar generación
        result = generate_image(prompt, api_key, size)
        if result:
            monitor.log_generation_request(prompt, size, result['task_id'])

            # Esperar a que termine
            final_result = wait_for_completion(result['task_id'], api_key)

            if final_result and final_result.get('files'):
                monitor.log_generation_success(
                    result['task_id'],
                    final_result['files'][0]['file_url']
                )
                return final_result
            else:
                monitor.log_generation_failure(result['task_id'], "No files in result")
                return None

    except Exception as e:
        monitor.log_generation_failure("unknown", str(e))
        return None

# Generar informe de estadísticas
stats = monitor.get_stats()
print(f"Generation Statistics: {stats}")

Conclusión

La API Seedream 4.5 en PoYo te ofrece una calidad ultra 4K sin precedentes, precisión profesional de texto, lógica avanzada de iluminación y estándares fotográficos comerciales. Siguiendo esta guía, podrás integrar estas potentes capacidades en tus aplicaciones para crear contenido visual profesional, ideal para e-commerce, publicidad y uso comercial.

La combinación de la tecnología revolucionaria de ByteDance con la infraestructura sólida de PoYo garantiza resultados consistentes y de alta calidad para tus flujos de trabajo en producción.

Para obtener más funciones avanzadas y consultar la documentación completa de la API, visita la documentación oficial de Seedream 4.5 API.

¿Listo para crear con calidad ultra 4K? Consigue tu clave API y empieza a generar con Seedream 4.5 hoy mismo.

---

¿Necesitas ayuda con la integración? Únete a nuestra comunidad de desarrolladores o consulta más tutoriales de API para técnicas avanzadas.