API Seedream 5.0 Lite : l'endpoint 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 Arteza l'est aussi via l'API. Voici la référence complète avec des exemples Python et JavaScript fonctionnels que vous pouvez intégrer en production dès aujourd'hui.

En bref

• POST /v1/images/generate - endpoint image unique
• POST /v1/images/batch - jusqu'à 50 images par requête
• Latence moyenne de 5-15 secondes avec support async et webhook
• SDK Python et JavaScript disponibles (seedance / @seedance/sdk)
• Authentification par token Bearer - générez vos clés dans Paramètres > Clés API

Aperçu de l'API

L'API Seedream 5.0 Lite offre un accès programmatique au pipeline de génération d'images sur la plateforme Arteza. Tout ce que propose l'interface web - texte vers image, deep thinking, transfert de style, rendu de texte - est accessible via l'API REST.

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

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

URL de base

https://api.arteza.ai/v1

Caractéristiques principales

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 votre clé et conservez-la en lieu sûr (elle n'est affichée qu'une seule fois)

En-tête d'authentification

Authorization: Bearer VOTRE_CLÉ_API

Tester l'authentification

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

Réponse :

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

Endpoint image unique

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

Ratios d'aspect

Préréglages de style

Format de réponse

Interrogation des 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 URLs d'images

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

Envie d'un texte aussi net ? Essayer 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"
}

# Soumettre une requête de génération
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"Tâche soumise : {task_id}")
print(f"Crédits débités : {task['credits_charged']}")
print(f"Crédits restants : {task['credits_remaining']}")

# Interroger jusqu'à la fin
while True:
    result = requests.get(
        f"{BASE_URL}/images/{task_id}",
        headers=headers
    ).json()

    if result["status"] == "completed":
        print(f"Image prête : {result['image_url']}")
        break
    elif result["status"] == "failed":
        print(f"Échec de la génération : {result.get('error', 'Erreur inconnue')}")
        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(`Tâche soumise : ${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 || 'Échec de la génération');
    }

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

// Utilisation
const result = await generateImage(
  'A cozy coffee shop interior with warm lighting',
  { aspectRatio: '16:9', deepThinking: true }
);
console.log(`URL de l'image : ${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"Enregistré : {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 du 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 des lots

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

Intégration des webhooks

Les webhooks éliminent le besoin d'interrogation. Lorsque la génération est terminée, l'API envoie un POST à votre URL.

Contenu 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', {})

        # Télécharger l'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)

        # Mettre à jour votre base de données
        update_generation_record(task_id, filename)

        print(f"Image enregistrée : {filename}")

    elif data['event'] == 'image.failed':
        print(f"Échec de la génération : {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 deep thinking

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 l'activer

Impact sur les performances

Le deep thinking ajoute environ 3-5 secondes mais ne coûte aucun crédit supplémentaire.

Gestion des erreurs

Format des réponses 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)  # Backoff exponentiel

Limites de débit et bonnes pratiques

Limites de débit par niveau

Bonnes pratiques

1. Privilégiez les webhooks à l'interrogation - plus efficace
2. Traitez par lot quand c'est 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 URLs d'images et les métadonnées dans votre base de données
5. Téléchargez rapidement - les URLs d'images expirent après 24 heures
6. Surveillez le solde de crédits - vérifiez credits_remaining pour éviter les interruptions
7. Utilisez les métadonnées - balisez les générations avec des identifiants de projet pour le suivi
8. Gérez les erreurs avec soin - toutes les générations ne réussissent 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 à la une lors de 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 produits pour e-commerce

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 pour passer d'un prompt texte à une image générée, avec une prise en charge complète du deep thinking, de la génération par lot et de l'intégration webhook.

Obtenir votre clé API → - 10 crédits offerts, générez votre clé depuis Paramètres > Clés API et commencez à développer en quelques minutes.