API Seedream 5.0 Lite : Point de terminaison de génération d'images le plus rapide

API REST, authentification Bearer, génération asynchrone, webhooks, traitement par lot natif jusqu'à 50 images par requête. Tout ce qui est disponible dans l'interface Web d'Arteza est également disponible dans l'API. Voici la référence complète avec des exemples Python et JavaScript fonctionnels que vous pouvez copier en production dès aujourd'hui.

Aperçu de l'API

L'API Seedream 5.0 Lite fournit un accès programmatique au pipeline de génération d'images sur la plateforme Arteza. Tout ce qui se trouve dans l'interface Web - texte vers image, réflexion approfondie, transfert de style, rendu de texte - est dans l'API REST.

L'API suit les conventions REST avec des corps de requête et de réponse JSON. La génération est asynchrone : soumettez une requête, obtenez un ID de tâche, puis interrogez ou recevez un webhook à la fin.

Aperçu complet des fonctionnalités dans notre guide complet.

URL de base

https://api.arteza.ai/v1

Caractéristiques clés

Authentification

Authentification par token Bearer. Générez votre clé API depuis le tableau de bord Arteza sous Paramètres > Clés API.

Obtenir votre clé API

1. S'inscrire ou connectez-vous à votre compte Arteza
2. Accédez à Paramètres > Clés API
3. Cliquez sur Générer une nouvelle clé
4. Copiez et stockez de manière sécurisée votre clé (affichée une seule fois)

En-tête d'authentification

Authorization: Bearer YOUR_API_KEY

Test de l'authentification

curl -H "Authorization: Bearer YOUR_API_KEY" \
     https://api.arteza.ai/v1/account/credits

Réponse :

{
  "credits_remaining": 1050,
  "tier": "starter"
}

Endpoint pour une seule image

POST /v1/images/generate

Requête minimale

{
  "model": "seedream-5.0-lite",
  "prompt": "A serene mountain landscape at sunrise"
}

Requête complète

{
  "model": "seedream-5.0-lite",
  "prompt": "Professional YouTube thumbnail with text 'TOP 10 TIPS' in bold red font, excited person on left, bright blue background",
  "aspect_ratio": "16:9",
  "deep_thinking": true,
  "style": "photorealistic",
  "webhook_url": "https://your-app.com/webhook/image-complete",
  "metadata": {
    "project": "youtube-thumbnails",
    "batch_id": "thumb-2026-04"
  }
}

Réponse

{
  "task_id": "img_abc123def456",
  "status": "processing",
  "model": "seedream-5.0-lite",
  "credits_charged": 7,
  "credits_remaining": 1043,
  "estimated_time_seconds": 10
}

Paramètres de la requête

Rapports d'aspect

Présets de style

Format de la réponse

Interrogation pour les résultats

GET /v1/images/{task_id}

En cours de traitement :

{
  "task_id": "img_abc123def456",
  "status": "processing",
  "progress": 0.65,
  "estimated_time_remaining": 5
}

Terminé :

{
  "task_id": "img_abc123def456",
  "status": "completed",
  "image_url": "https://cdn.arteza.ai/generated/img_abc123def456.png",
  "image_url_webp": "https://cdn.arteza.ai/generated/img_abc123def456.webp",
  "width": 1024,
  "height": 1024,
  "model": "seedream-5.0-lite",
  "deep_thinking_used": true,
  "credits_charged": 7,
  "metadata": {
    "project": "youtube-thumbnails",
    "batch_id": "thumb-2026-04"
  },
  "created_at": "2026-04-10T14:30:00Z"
}

Expiration des URL d'image

Les URL des images générées sont valides pendant 24 heures. Téléchargez et stockez les images dans votre propre espace de stockage dans ce délai.

Vous voulez un rendu de texte aussi propre ? Essayez Seedream 5.0 Lite gratuitement →

Exemple Python

import requests
import time

API_KEY = "your_api_key_here"
BASE_URL = "https://api.arteza.ai/v1"

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

# Submit generation request
response = requests.post(
    f"{BASE_URL}/images/generate",
    headers=headers,
    json={
        "model": "seedream-5.0-lite",
        "prompt": "A futuristic city skyline at sunset with flying cars",
        "aspect_ratio": "16:9",
        "deep_thinking": True
    }
)

task = response.json()
task_id = task["task_id"]
print(f"Task submitted: {task_id}")
print(f"Credits charged: {task['credits_charged']}")
print(f"Credits remaining: {task['credits_remaining']}")

# Poll for completion
while True:
    result = requests.get(
        f"{BASE_URL}/images/{task_id}",
        headers=headers
    ).json()

    if result["status"] == "completed":
        print(f"Image ready: {result['image_url']}")
        break
    elif result["status"] == "failed":
        print(f"Generation failed: {result.get('error', 'Unknown error')}")
        break

    time.sleep(2)

Exemple JavaScript

const API_KEY = 'your_api_key_here';
const BASE_URL = 'https://api.arteza.ai/v1';

async function generateImage(prompt, options = {}) {
  const response = await fetch(`${BASE_URL}/images/generate`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      model: 'seedream-5.0-lite',
      prompt,
      aspect_ratio: options.aspectRatio || '1:1',
      deep_thinking: options.deepThinking || false,
      ...options
    })
  });

  const task = await response.json();
  console.log(`Task submitted: ${task.task_id}`);

  while (true) {
    const result = await fetch(
      `${BASE_URL}/images/${task.task_id}`,
      { headers: { 'Authorization': `Bearer ${API_KEY}` } }
    ).then(r => r.json());

    if (result.status === 'completed') {
      return result;
    }
    if (result.status === 'failed') {
      throw new Error(result.error || 'Generation failed');
    }

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

// Usage
const result = await generateImage(
  'A cozy coffee shop interior with warm lighting',
  { aspectRatio: '16:9', deepThinking: true }
);
console.log(`Image URL: ${result.image_url}`);

Télécharger les images générées

import requests

def download_image(image_url, filename):
    response = requests.get(image_url)
    with open(filename, 'wb') as f:
        f.write(response.content)
    print(f"Saved: {filename}")

download_image(result['image_url'], 'output/my_image.png')

Endpoint de génération par lot

Pour plusieurs images en une seule requête :

POST /v1/images/batch

Requête par lot

{
  "generations": [
    {
      "prompt": "Minimalist logo design, blue circle with lightning bolt",
      "model": "seedream-5.0-lite",
      "aspect_ratio": "1:1",
      "deep_thinking": true
    },
    {
      "prompt": "Professional headshot background, soft gradient",
      "model": "seedream-5.0-lite",
      "aspect_ratio": "1:1",
      "deep_thinking": false
    },
    {
      "prompt": "YouTube thumbnail with text 'MUST WATCH' in red",
      "model": "seedream-5.0-lite",
      "aspect_ratio": "16:9",
      "deep_thinking": true
    }
  ],
  "webhook_url": "https://your-app.com/webhook/batch-complete"
}

Réponse par lot

{
  "batch_id": "batch_xyz789",
  "status": "processing",
  "total_generations": 3,
  "total_credits_charged": 21,
  "credits_remaining": 1029
}

Interrogation du statut du lot

GET /v1/images/batch/{batch_id}

{
  "batch_id": "batch_xyz789",
  "status": "completed",
  "results": [
    {
      "index": 0,
      "status": "completed",
      "task_id": "img_001",
      "image_url": "https://cdn.arteza.ai/generated/img_001.png"
    },
    {
      "index": 1,
      "status": "completed",
      "task_id": "img_002",
      "image_url": "https://cdn.arteza.ai/generated/img_002.png"
    },
    {
      "index": 2,
      "status": "completed",
      "task_id": "img_003",
      "image_url": "https://cdn.arteza.ai/generated/img_003.png"
    }
  ]
}

Limites de lot

Pour les workflows par lot, consultez notre guide de génération en masse.

Intégration des webhooks

Les webhooks éliminent l'interrogation. Lorsque la génération est terminée, l'API effectue un POST vers votre URL.

Charge utile du webhook

{
  "event": "image.completed",
  "task_id": "img_abc123def456",
  "batch_id": "batch_xyz789",
  "status": "completed",
  "image_url": "https://cdn.arteza.ai/generated/img_abc123def456.png",
  "model": "seedream-5.0-lite",
  "credits_charged": 7,
  "metadata": {
    "project": "youtube-thumbnails"
  },
  "created_at": "2026-04-10T14:30:00Z"
}

Exemple de gestionnaire (Python/Flask)

from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

@app.route('/webhook/image-complete', methods=['POST'])
def handle_image_webhook():
    data = request.json

    if data['event'] == 'image.completed':
        task_id = data['task_id']
        image_url = data['image_url']
        metadata = data.get('metadata', {})

        # Download image
        img_response = requests.get(image_url)
        filename = f"images/{metadata.get('project', 'default')}/{task_id}.png"
        with open(filename, 'wb') as f:
            f.write(img_response.content)

        # Update your database
        update_generation_record(task_id, filename)

        print(f"Image saved: {filename}")

    elif data['event'] == 'image.failed':
        print(f"Generation failed: {data.get('error')}")

    return jsonify({'status': 'ok'}), 200

Sécurité des webhooks

Vérifiez l'authenticité du webhook via l'en-tête X-Seedance-Signature :

import hmac
import hashlib

def verify_webhook(payload, signature, secret):
    expected = hmac.new(
        secret.encode(),
        payload.encode(),
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(expected, signature)

Mode de réflexion approfondie

Contrôlé par le paramètre booléen deep_thinking. Lorsqu'il est activé, le modèle effectue un raisonnement supplémentaire avant la génération.

Quand activer

Impact sur les performances

La réflexion approfondie ajoute environ 3 à 5 secondes mais ne coûte zéro crédit supplémentaire.

Gestion des erreurs

Format de réponse d'erreur

{
  "error": {
    "code": "insufficient_credits",
    "message": "Not enough credits to complete this generation. Required: 7, Available: 3",
    "status": 402
  }
}

Codes d'erreur

Stratégie de nouvelle tentative

import time

def generate_with_retry(prompt, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = requests.post(
                f"{BASE_URL}/images/generate",
                headers=headers,
                json={
                    "model": "seedream-5.0-lite",
                    "prompt": prompt
                }
            )

            if response.status_code == 429:
                retry_after = int(response.headers.get('Retry-After', 5))
                time.sleep(retry_after)
                continue

            response.raise_for_status()
            return response.json()

        except requests.exceptions.RequestException as e:
            if attempt == max_retries - 1:
                raise
            time.sleep(2 ** attempt)  # Exponential backoff

Limites de débit et meilleures pratiques

Limites de débit par niveau

Meilleures pratiques

1. Utilisez les webhooks plutôt que l'interrogation - plus efficace
2. Regroupez quand possible - une requête par lot vaut mieux que 50 requêtes individuelles
3. Backoff exponentiel - gérez les limites de débit avec élégance
4. Mettez en cache les résultats - stockez les URL d'image et les métadonnées dans votre base de données
5. Téléchargez rapidement - les URL des images expirent après 24 heures
6. Surveillez le solde des crédits - vérifiez credits_remaining pour éviter les interruptions
7. Utilisez les métadonnées - étiquetez les générations avec les ID de projet pour le suivi
8. Gérez les erreurs avec élégance - toutes les générations n'aboutissent pas

Installation du SDK

Python :

pip install seedance

from seedance import SeedanceClient

client = SeedanceClient(api_key="your_key")
result = client.images.generate(
    model="seedream-5.0-lite",
    prompt="A beautiful sunset",
    deep_thinking=True
)

JavaScript :

npm install @seedance/sdk

import { SeedanceClient } from '@seedance/sdk';

const client = new SeedanceClient({ apiKey: 'your_key' });
const result = await client.images.generate({
    model: 'seedream-5.0-lite',
    prompt: 'A beautiful sunset',
    deepThinking: true
});

Modèles d'intégration courants

Intégration CMS

Générez automatiquement des images en vedette à la création d'un article :

@app.route('/cms/webhook/new-post', methods=['POST'])
def handle_new_post():
    post = request.json

    result = generate_image(
        prompt=f"Blog header image for article about {post['title']}, "
               f"professional editorial style, 16:9",
        aspect_ratio="16:9",
        deep_thinking=True,
        metadata={"post_id": post["id"]}
    )

    update_post_featured_image(post["id"], result["image_url"])

Images de produits de commerce électronique

def generate_product_images(product):
    prompts = [
        f"Product photo of {product.name}, white background, studio lighting, 1:1",
        f"Lifestyle photo of {product.name} in use, natural setting, 16:9",
        f"Product detail close-up of {product.name}, macro photography, 1:1"
    ]

    batch = client.images.batch_generate(
        generations=[
            {"model": "seedream-5.0-lite", "prompt": p}
            for p in prompts
        ]
    )

    return batch

Automatisation des réseaux sociaux

def generate_weekly_social_content(brand, topics):
    generations = []
    for topic in topics:
        generations.append({
            "model": "seedream-5.0-lite",
            "prompt": f"{brand.style_prefix} {topic}, social media post, 1:1",
            "aspect_ratio": "1:1",
            "deep_thinking": True,
            "metadata": {"topic": topic, "platform": "instagram"}
        })

    return client.images.batch_generate(generations=generations)

---

L'API Seedream 5.0 Lite est le chemin le plus rapide du prompt textuel à l'image générée avec support complet de la réflexion approfondie, de la génération par lot et de l'intégration des webhooks.

Obtenez votre clé API → - 50 crédits gratuits, générez votre clé à partir de Paramètres > Clés API, commencez à construire en quelques minutes.