L’API GPT Image 2.5 è disponibile. Crea e modifica immagini →
PoYoPoYo
tutorials

Come utilizzare Seedream 4.5 API su PoYo: guida completa per gli sviluppatori

Poyo.ai Team
Updated
14 min read
Share:

Come utilizzare Seedream 4.5 API su PoYo

Seedream 4.5 API, basato sulla tecnologia di generazione di immagini ultra 4K di ByteDance, offre la creazione di contenuti visivi di livello professionale a 5 crediti per generazione, circa $0.025 USD su PoYo. Questa guida illustra l'implementazione della logica di illuminazione avanzata, della precisione del testo professionale e della qualità della fotografia commerciale utilizzando l'API di PoYo.

Panoramica del modello Seedream 4.5

Seedream 4.5 è un modello di generazione di immagini AI all'avanguardia sviluppato da ByteDance, che offre funzionalità di risoluzione ultra 4K con qualità di output di livello professionale. Su PoYo.ai, questo modello eccelle in:

  • Risoluzione Ultra 4K: genera immagini nitide e dettagliate fino a 4096x4096 pixel
  • Precisione del testo professionale: rendering avanzato del testo con tipografia perfetta
  • Logica dell'illuminazione intelligente: calcoli sofisticati di illuminazione e ombre
  • Qualità fotografica commerciale: composizione e precisione dei colori di livello professionale
  • Proporzioni multiple: supporto per 1:1, 4:3, 3:4, 16:9, 9:16, 3:2, 2:3, 21:9

Pagina dei dettagli del modello

Visita la pagina del modello Seedream 4.5 API per:

  • Playground interattivo: prova API direttamente nel tuo browser
  • Esempi dal vivo: visualizza generazioni e prompt di esempio
  • Documentazione API: riferimenti completi ai parametri
  • Informazioni sui prezzi: tariffe attuali (5 crediti = $0.025 per immagine)
  • Benchmark delle prestazioni: confronti di velocità e qualità

Iniziare con Seedream 4.5 API

Passaggio 1: configura il tuo account PoYo

Innanzitutto, crea il tuo account PoYo e ottieni le tue credenziali API:

  1. Iscriviti su PoYo.ai
  2. Genera la tua chiave API nel dashboard
  3. Aggiungi crediti al tuo account (Seedream 4.5 costa 5 crediti per generazione)
  4. Esplora il modello nella pagina dei dettagli Seedream 4.5

Passaggio 2: installa le dipendenze richieste

# For Node.js/JavaScript
npm install axios

# For Python
pip install requests

# For cURL (no installation needed)

Generazione di base da testo a immagine

Implementazione 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', // Optional webhook
        input: {
          prompt: prompt,
          size: size, // Options: '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);
  }
};

// Example usage with professional photography prompt
generateImage('Professional commercial product photography of luxury watch with cinematic lighting and golden ratio composition', '16:9');

Implementazione 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",  # Optional webhook
        "input": {
            "prompt": prompt,
            "size": size,  # Options: '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

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

Implementazione 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
    }
  }'

Funzionalità avanzate di Seedream 4.5

1. Precisione del testo professionale

Seedream 4.5 eccelle nel rendering di testo e tipografia nitidi con una precisione di livello commerciale:

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}`);
  }
};

// Generate images with perfect text rendering
generateTextRichImages();

2. Logica di illuminazione avanzata

Utilizza il rivoluzionario motore di illuminazione di Seedream 4.5 per la qualità della fotografia commerciale:

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",  # Perfect for e-commerce
            "n": 1
        }
    }

    return generate_image_with_payload(payload, api_key)

# Generate commercial-quality product photos
products = ["luxury skincare bottle", "premium headphones", "artisan coffee package"]
for product in products:
    result = generate_commercial_photography(product, "YOUR_API_KEY")

3. Ragionamento della composizione migliorato

Seedream 4.5 comprende i termini della fotografia professionale e le tecniche di composizione:

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. Uscita con risoluzione Ultra 4K

Genera immagini ad alta risoluzione adatte per l'uso commerciale:

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']

# Generate 4K quality images for different use cases
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")

Modifica delle immagini con Seedream 4.5

Trasformazione da immagine a immagine

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', // Optional
        input: {
          prompt: editPrompt,
          image_urls: imageUrls, // Array of reference image URLs (max 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);
  }
};

// Example: Enhance product photography with professional lighting
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'
);

Controllo dello stato di generazione

Controllo manuale dello stato

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; // Returns the task data
  } 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('Ultra 4K image generated successfully!');
      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;
    }

    // Status is 'processing'
    await new Promise(resolve => setTimeout(resolve, 3000)); // Wait 3 seconds
  }

  console.error('Maximum polling attempts reached');
  return null;
};

// Complete workflow example
const completeGeneration = async (prompt, size = '16:9') => {
  // Step 1: Submit generation request
  const generation = await generateImage(prompt, size);

  if (!generation) return null;

  // Step 2: Poll for results
  const result = await pollForResult(generation.task_id);

  return result;
};

Controllo dello stato in 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("Ultra 4K image generated successfully!")
            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)  # Wait 3 seconds

    print("Maximum attempts reached")
    return None

# Complete workflow
def complete_image_generation(prompt, api_key, size='16:9'):
    # Step 1: Submit request
    task_result = generate_image(prompt, api_key, size)

    if not task_result:
        return None

    # Step 2: Wait for completion
    final_result = wait_for_completion(task_result['task_id'], api_key)

    return final_result

Gestione degli errori e best practice

Gestione completa degli errori

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 // 30 second timeout
        }
      );

      return response.data.data;

    } catch (error) {
      if (error.response) {
        // Server responded with error status
        const status = error.response.status;
        const message = error.response.data?.message || 'Unknown error';

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

        // Don't retry for certain errors
        if (status === 401 || status === 403) {
          throw new Error('Authentication failed. Check your API key.');
        }

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

      } else if (error.request) {
        console.error('Network error:', error.message);
      } else {
        console.error('Request setup error:', error.message);
      }

      // If this was the last attempt, throw the error
      if (attempt === retries - 1) {
        throw error;
      }

      // Wait before retrying (exponential backoff)
      const delay = Math.pow(2, attempt) * 1000;
      console.log(`Retrying in ${delay}ms... (Attempt ${attempt + 1}/${retries})`);
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
};

Casi d'uso commerciali

Fotografia di prodotti per l'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;
};

// Generate product photos for e-commerce
const productPhotos = await generateProductPhotos('luxury smartphone');

Marketing e pubblicità

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

    for size in sizes:
        # Determine format based on size
        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

# Generate complete marketing campaign assets
campaign_assets = generate_marketing_assets(
    "luxury travel experience campaign",
    "gold and deep blue color scheme",
    ['1:1', '16:9', '9:16', '21:9']
)

Prompt per l'ottimizzazione delle prestazioni

1. Ingegneria dei prompt per Seedream 4.5

  • Utilizza una terminologia professionale: "fotografia commerciale", "illuminazione cinematografica", "ultra 4K"
  • Specifica la composizione: "sezione aurea", "regola dei terzi", "composizione diagonale"
  • Includi direttive sulla qualità: "grado professionale", "standard commerciali", "pronto per la stampa"
  • Sfrutta le funzionalità avanzate: "perfezionamento visivo migliorato", "logica di illuminazione avanzata"
// Optimized prompt structure
const buildOptimizedPrompt = (subject, style, quality, composition) => {
  return `${subject}, ${style}, ${quality}, ${composition}, ultra 4K resolution, commercial photography standards, enhanced visual refinement`;
};

// Examples
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. Selezione delle proporzioni

Scegli le proporzioni ottimali per il tuo caso d'uso:

const aspectRatioGuide = {
  '1:1': 'Social media posts, profile pictures, product shots',
  '4:3': 'Traditional displays, presentations, desktop wallpapers',
  '3:4': 'Mobile screens, portrait photography, book covers',
  '16:9': 'Video thumbnails, wide banners, landscape photography',
  '9:16': 'Mobile stories, vertical videos, smartphone wallpapers',
  '3:2': 'Classic photography, print media, photo frames',
  '2:3': 'Portrait prints, magazine covers, book layouts',
  '21:9': 'Ultra-wide banners, cinema displays, panoramic shots'
};

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. Elaborazione batch per flussi di lavoro commerciali

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;

    // Process in batches to avoid overwhelming the 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);
      }

      // Wait between batches to respect rate limits
      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;
  }
}

// Usage example
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
});

Considerazioni sulla distribuzione della produzione

1. Gestione delle chiavi API

// Environment-based configuration
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
};

// Validate configuration
if (!config.apiKey) {
  throw new Error('POYO_API_KEY environment variable is required');
}

2. Monitoraggio e registrazione

import logging
from datetime import datetime

# Configure 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"Generation request submitted - Task: {task_id}, Size: {size}, Prompt: {prompt[:50]}...")
        self.generation_stats['total_requests'] += 1

    def log_generation_success(self, task_id, image_url):
        logger.info(f"Generation completed successfully - Task: {task_id}, URL: {image_url}")
        self.generation_stats['successful_generations'] += 1
        self.generation_stats['total_credits_used'] += 5  # Seedream 4.5 costs 5 credits

    def log_generation_failure(self, task_id, error_message):
        logger.error(f"Generation failed - Task: {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)
        }

# Usage
monitor = Seedream45Monitor()

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

            # Wait for completion
            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

# Generate stats report
stats = monitor.get_stats()
print(f"Generation Statistics: {stats}")

Conclusione

Seedream 4.5 API su PoYo offre una qualità ultra 4K senza precedenti con precisione del testo professionale, logica di illuminazione avanzata e standard di fotografia commerciale. Seguendo questa guida, puoi integrare queste potenti funzionalità nelle tue applicazioni e creare contenuti visivi di livello professionale adatti per l'e-commerce, la pubblicità e l'uso commerciale.

La combinazione della tecnologia rivoluzionaria di ByteDance con l'infrastruttura affidabile di PoYo garantisce risultati coerenti e di alta qualità per i flussi di lavoro di produzione.

Per funzionalità più avanzate e la documentazione API completa, visita la documentazione ufficiale Seedream 4.5 API.

Pronto per iniziare a costruire con la qualità ultra 4K? Ottieni la tua chiave API e inizia a creare con Seedream 4.5 oggi stesso.

Hai bisogno di aiuto con l'implementazione? Unisciti alla nostra comunità di sviluppatori o dai un'occhiata ad altri tutorial API per tecniche avanzate.

Share: