API Seedream v4.5 : intégrez des images IA dans votre application

Intégrer la génération d'images par IA dans votre application impliquait autrefois de choisir entre trois mauvaises options : faire tourner Stable Diffusion soi-même (infrastructure coûteuse), payer OpenAI au token (coûts imprévisibles) ou souscrire à une API par abonnement (capacité gaspillée). L'API Seedream v4.5 fonctionne différemment : facturation à l'image à 0,10 dollar, REST standard et temps de réponse mesurés en secondes. Ce guide vous emmène de zéro à votre première génération en moins de 10 minutes.

En bref

• L'API Seedream v4.5 coûte 1 crédits ($0,10) par image générée
• API REST standard avec requêtes et réponses JSON
• Paramètres : prompt, résolution, format, num_images (1-6), guidance scale
• Temps de réponse typique : 5-15 secondes par génération
• Forfaits à partir de 5 dollars par mois - les crédits ne sont consommés qu'à la génération

Ce pour quoi l'API excelle

L'API Seedream v4.5 convient aux applications qui ont besoin d'une génération d'images par IA à la demande avec des coûts prévisibles à l'image. Cas d'usage courants :

Produits SaaS permettant aux utilisateurs de générer des images dans le cadre de leur flux de travail : outils de design, plateformes marketing, applications de création de contenu.

Plateformes e-commerce générant des visuels lifestyle de produits ou des en-têtes de catégorie de façon programmatique.

Outils d'automatisation marketing produisant des visuels de campagne à partir d'entrées structurées.

Systèmes de gestion de contenu proposant la génération d'images par IA comme fonctionnalité native.

Projets développeur et scripts d'automatisation pour tout flux de travail nécessitant une génération d'images à grande échelle.

Applications mobiles qui appellent l'API depuis un service backend pour garder la génération d'images hors de l'appareil.

Si votre cas d'usage correspond à l'un de ces scénarios, ce guide vous permettra d'intégrer rapidement.

Authentification et prise en main

Étape 1 : Obtenir une clé API

S'inscrire pour créer un compte Arteza si vous n'en avez pas encore. Accédez aux paramètres de votre compte et générez une clé API. Traitez cette clé comme un mot de passe : ne la commitez pas dans des dépôts publics.

Étape 2 : Créditer votre compte

L'utilisation de l'API puise dans le même solde de crédits que l'utilisation web. Vos 10 crédits offerts à l'inscription fonctionnent sur les appels API. Pour un usage en production, souscrivez depuis page de tarification à partir de 5 dollars.

Étape 3 : Effectuer votre première requête

L'endpoint API pour Seedream v4.5 est :

POST https://api.arteza.ai/v1/images/generate

Corps de requête minimal :

{
  "model": "seedream-v4-5",
  "prompt": "A cozy bookstore at dusk, warm window light",
  "width": 2048,
  "height": 2048,
  "num_images": 1
}

Incluez votre clé API dans l'en-tête Authorization :

Authorization: Bearer YOUR_API_KEY

Référence complète des paramètres

Résolutions prises en charge

Seedream v4.5 prend en charge plusieurs options de résolution jusqu'à 4 mégapixels :

Exemples de code

Node.js (Fetch)

const generateImage = async (prompt) => {
  const response = await fetch(
    'https://api.arteza.ai/v1/images/generate',
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.SEEDANCE_API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        model: 'seedream-v4-5',
        prompt: prompt,
        width: 2048,
        height: 2048,
        num_images: 1,
      }),
    }
  );

  if (!response.ok) {
    throw new Error(`API error: ${response.status}`);
  }

  const data = await response.json();
  return data.images[0].url;
};

// Utilisation
const imageUrl = await generateImage(
  'A cozy bookstore at dusk, warm window light, editorial photography'
);
console.log(imageUrl);

Python (Requests)

import os
import requests

def generate_image(prompt, width=2048, height=2048, num_images=1):
    response = requests.post(
        'https://api.arteza.ai/v1/images/generate',
        headers={
            'Authorization': f'Bearer {os.environ["SEEDANCE_API_KEY"]}',
            'Content-Type': 'application/json',
        },
        json={
            'model': 'seedream-v4-5',
            'prompt': prompt,
            'width': width,
            'height': height,
            'num_images': num_images,
        },
    )
    response.raise_for_status()
    data = response.json()
    return [img['url'] for img in data['images']]

# Utilisation
urls = generate_image(
    'An editorial product photograph of a ceramic coffee mug, '
    'warm morning light, minimalist composition'
)
print(urls)

cURL

curl -X POST https://api.arteza.ai/v1/images/generate \
  -H "Authorization: Bearer $SEEDANCE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedream-v4-5",
    "prompt": "A futuristic city skyline at sunset, cinematic photography",
    "width": 2048,
    "height": 1152,
    "num_images": 1
  }'

Go

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "os"
)

type GenerateRequest struct {
    Model     string `json:"model"`
    Prompt    string `json:"prompt"`
    Width     int    `json:"width"`
    Height    int    `json:"height"`
    NumImages int    `json:"num_images"`
}

func generateImage(prompt string) (string, error) {
    reqBody := GenerateRequest{
        Model:     "seedream-v4-5",
        Prompt:    prompt,
        Width:     2048,
        Height:    2048,
        NumImages: 1,
    }

    jsonData, _ := json.Marshal(reqBody)
    req, _ := http.NewRequest(
        "POST",
        "https://api.arteza.ai/v1/images/generate",
        bytes.NewBuffer(jsonData),
    )
    req.Header.Set("Authorization", "Bearer "+os.Getenv("SEEDANCE_API_KEY"))
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    images := result["images"].([]interface{})
    firstImage := images[0].(map[string]interface{})
    return firstImage["url"].(string), nil
}

Format de la réponse

Les réponses réussies renvoient du JSON avec cette structure :

{
  "id": "gen_abc123xyz",
  "model": "seedream-v4-5",
  "created": 1712764800,
  "images": [
    {
      "url": "https://cdn.arteza.ai/gen/abc123.png",
      "width": 2048,
      "height": 2048,
      "seed": 42871
    }
  ],
  "credits_used": 8,
  "credits_remaining": 1042
}

Les URLs d'images sont valables 24 heures. Téléchargez et stockez les images immédiatement si vous avez besoin d'un accès permanent.

Vous voulez ce niveau de détail ? Essayer Seedream v4.5 gratuitement →

Prêt à commencer l'intégration ? Obtenir votre clé API →

Gestion des erreurs

L'API renvoie des codes de statut HTTP standard :

Exemple de réponse d'erreur :

{
  "error": {
    "code": "insufficient_credits",
    "message": "Your account has insufficient credits for this request",
    "credits_required": 8,
    "credits_available": 3
  }
}

Implémentez toujours une gestion des erreurs et des nouvelles tentatives pour les erreurs 429 et 500. Ne relancez pas les erreurs 400 et 401 : celles-ci nécessitent de corriger la requête elle-même.

Bonnes pratiques pour la production

Limitation de débit

Les limites de débit par défaut permettent un débit de production raisonnable. Si vous avez besoin de limites plus élevées, contactez le support en précisant votre cas d'usage.

Implémentez un backoff exponentiel sur les erreurs 429 :

import time

def generate_with_retry(prompt, max_retries=3):
    for attempt in range(max_retries):
        try:
            return generate_image(prompt)
        except requests.HTTPError as e:
            if e.response.status_code == 429:
                wait_time = 2 ** attempt
                time.sleep(wait_time)
                continue
            raise
    raise Exception("Max retries exceeded")

Gestion des crédits

Surveillez le champ credits_remaining dans chaque réponse. Configurez des alertes lorsque le solde passe sous un seuil afin de pouvoir recharger avant que le trafic en production n'atteigne zéro crédit.

def check_credits(response):
    remaining = response.json().get('credits_remaining', 0)
    if remaining < 100:
        send_alert(f'Avertissement de crédits bas : {remaining} crédits')

Traitement asynchrone

Pour les applications orientées utilisateur, traitez la génération d'images comme une opération asynchrone. Ne bloquez pas le thread UI sur un appel API de 5-15 secondes. Approches possibles :

• Renvoyer immédiatement un identifiant de tâche, puis interroger pour la complétion
• Utiliser des webhooks (si pris en charge) pour les notifications de complétion
• Générer de façon spéculative en arrière-plan et mettre les résultats en cache

Mise en cache

Les images générées sont déterministes pour un même prompt et une même graine. Mettez agressivement en cache par hash de prompt afin d'éviter de régénérer des images identiques.

import hashlib

def prompt_cache_key(prompt, width, height, seed):
    raw = f'{prompt}|{width}x{height}|{seed}'
    return hashlib.sha256(raw.encode()).hexdigest()

Sécurité des prompts

Si votre application expose les prompts aux utilisateurs finaux, implémentez un filtrage de contenu avant d'envoyer à l'API. Arteza dispose de politiques de contenu : les prompts qui les enfreignent renverront des erreurs, ce qui gaspille des crédits et crée des échecs visibles par l'utilisateur.

Tarification de l'utilisation API

L'utilisation de l'API puise dans le solde de crédits de votre compte au même tarif que l'utilisation web.

Les crédits proviennent du même niveaux de tarification, que vous les utilisiez via le web ou via l'API :

• Starter : 5 dollars = 60 crédits par mois = 60 images
• Creator : 25 dollars = 300 crédits par mois = 300 images
• Pro : 50 dollars = 700 crédits par mois = 700 images
• Studio : 120 dollars = 1 800 crédits par mois = 1 800 images

Les clients à volume élevé peuvent contacter le support pour connaître les tarifs dégressifs lors d'une utilisation soutenue au-delà de 100 000 images par mois.

Combinaison avec d'autres modèles Arteza

Votre application peut utiliser plusieurs modèles Seedance via la même API en changeant le paramètre model :

• seedream-v4-5 - 1 crédits - qualité phare
• seedream-v3 - 1 crédit - plus rapide, plus simple
• seedream-5-lite - 1 crédit - mode de réflexion approfondie
• seedream-5-edit - 1 crédit - édition d'images
• seedance-2 - génération vidéo (endpoint différent)

Pour les applications nécessitant des capacités d'édition en plus de la génération, seedream-5-edit gère l'édition d'images par texte. Consultez Documentation de Seedream 5 Edit pour plus de détails.

Considérations de sécurité

N'exposez jamais les clés API côté client. Faites toujours transiter les appels API par votre backend. Des clés exposées peuvent être utilisées pour vider votre solde de crédits.

Faites tourner les clés régulièrement. Si une clé est compromise, révoquez-la et générez-en une nouvelle.

Journalisez les requêtes pour le débogage. Incluez les identifiants de requête dans vos logs afin de pouvoir corréler les échecs avec les réponses de l'API.

Implémentez des quotas d'utilisation par utilisateur. Si votre application propose la génération par IA comme fonctionnalité, limitez la consommation par utilisateur pour prévenir les abus.

Questions fréquentes

Existe-t-il un niveau gratuit pour l'API ? Vos 10 crédits offerts à l'inscription fonctionnent sur les appels API. Cela représente 10 générations Seedream v4.5 gratuites pour tester l'intégration avant de payer.

Quel est le temps de réponse typique ? 5-15 secondes pour Seedream v4.5, selon la résolution et la charge actuelle.

Puis-je utiliser l'API pour des produits commerciaux ? Oui. L'usage commercial est inclus. Les images générées par vos clients leur appartiennent et peuvent être utilisées à toute fin légitime.

Existe-t-il un SDK Python ? Les SDK officiels sont en cours de développement. L'API REST actuelle fonctionne parfaitement avec les bibliothèques HTTP standard dans n'importe quel langage.

Comment gérer les erreurs de politique de contenu ? Affichez des messages à l'utilisateur expliquant que le prompt a été rejeté. Journalisez l'erreur spécifique pour le débogage.

Que se passe-t-il si mes crédits s'épuisent en cours de requête ? L'API renvoie une erreur 402 avant le début de la génération. Aucune facturation partielle n'a lieu : vous obtenez soit l'image complète, soit une erreur.

Puis-je grouper plusieurs prompts dans une seule requête ? Pas directement. Utilisez num_images: 6 pour obtenir des variations du même prompt, ou effectuez des appels API parallèles pour des prompts différents.

---

L'API Seedream v4.5 vous offre une génération d'images par IA prête pour la production, avec une tarification prévisible à l'image et des conventions REST standard. Pour la plupart des intégrations, vous pouvez passer de la clé API à la première génération fonctionnelle en moins de 10 minutes. Pour toute question ou tarification au volume, contactez-nous via votre tableau de bord.

Commencez à intégrer dès aujourd'hui. Obtenir votre clé API → | Voir la tarification complète → | Lire le guide v4.5 →