API Seedream v4.5 : Intégrez les images IA dans votre application

L'intégration de la génération d'images IA dans votre application signifiait autrefois choisir entre trois mauvaises options : exécuter Stable Diffusion vous-même (infrastructure coûteuse), payer des tarifs par jeton à OpenAI (coûts imprévisibles), ou vous engager sur une API par abonnement (capacité gaspillée). L'API Seedream v4.5 est construite différemment : paiement par image à 0,08 dollars, REST standard, et des temps de réponse mesurés en secondes. Ce guide vous fait passer de zéro à première génération en moins de 10 minutes.

Ce que l'API fait bien

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

Produits SaaS qui permettent aux utilisateurs de générer des images dans le cadre de leur flux de travail : outils de conception, plates-formes marketing, applications de création de contenu.

Plates-formes de commerce électronique générant des images de style de vie de produits ou des en-têtes de catégories par programmation.

Outils d'automatisation marketing produisant des visuels de campagne basés sur des entrées structurées.

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

Projets de 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 à partir d'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 cas, ce guide vous permettra d'intégrer rapidement.

Authentification et démarrage

Étape 1 : Obtenir une clé API

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

Étape 2 : Ajouter des crédits à votre compte

L'utilisation de l'API puise dans le même solde de crédits que l'utilisation web. Vos 50 crédits d'inscription gratuits fonctionnent sur les appels API. Pour une utilisation en production, abonnez-vous à partir de page de tarification à partir de 10 dollars.

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

Le point de terminaison API pour Seedream v4.5 est :

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

Corps de requête minimum :

{
  "model": "seedream-v4-5",
  "prompt": "Une librairie accueillante au crépuscule, lumière chaude de la fenêtre",
  "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 supporte 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;
};

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

# Usage
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 réponse

Les réponses réussies retournent 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 URL d'images sont valides pendant 24 heures. Téléchargez et stockez les images immédiatement si vous avez besoin d'un accès permanent.

Voulez-vous ce niveau de détail ? Essayez gratuitement Seedream v4.5 →

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

Gestion des erreurs

L'API retourne les 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 la gestion des erreurs et les tentatives pour les erreurs 429 et 500. Ne réessayez pas les erreurs 400 et 401, celles-ci nécessitent de corriger la requête elle-même.

Meilleures pratiques pour l'utilisation en 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 avec les détails de 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. Configurer des alertes lorsque le solde tombe en dessous d'un seuil afin que vous puissiez recharger avant que le trafic de production n'atteigne zéro crédit.

def check_credits(response):
    remaining = response.json().get('credits_remaining', 0)
    if remaining < 100:
        send_alert(f'Low credit warning: {remaining} credits')

Traitement asynchrone

Pour les applications destinées aux utilisateurs, traitez la génération d'images comme asynchrone. Ne bloquez pas le thread de l'interface utilisateur sur un appel API de 5 à 15 secondes. Motifs :

• Retourner immédiatement un ID de travail, interroger l'achèvement
• Utiliser des webhooks (s'ils sont supportés) pour les notifications d'achèvement
• Générer spéculativement en arrière-plan et mettre en cache les résultats

Mise en cache

Les images générées sont déterministes avec le même prompt et la même graine. Mettez en cache agressivement par hash de prompt pour é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 a des politiques de contenu : les prompts qui les violent retourneront des erreurs, gaspillant des crédits et créant des défaillances visibles par l'utilisateur.

Tarification pour l'utilisation de l'API

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

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

• Starter : 10 dollars = 1 050 crédits = ~131 images
• Popular : 25 dollars = 2 750 crédits = ~343 images
• Creator : 50 dollars = 5 750 crédits = ~718 images
• Studio : 100 dollars = 12 000 crédits = ~1 500 images

Les clients avec un volume plus élevé peuvent contacter le support pour obtenir un tarif volume pour une utilisation soutenue au-dessus de 100 000 images/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 : 8 crédits : qualité phare
• seedream-v3 : 6 crédits : plus rapide, plus simple
• seedream-5-lite : 7 crédits : mode réflexion approfondie
• seedream-5-edit : 7 crédits : édition d'images
• seedance-2 : génération vidéo (point de terminaison différent)

Pour les applications qui ont besoin de capacités d'édition en plus de la génération, seedream-5-edit gère l'édition d'images basée sur du texte. Consultez le 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. Acheminez toujours les appels API via votre backend. Les clés exposées peuvent être utilisées pour épuiser votre solde de crédits.

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

Enregistrez les requêtes pour le débogage. Incluez les ID de requête dans vos journaux afin de pouvoir corréler les défaillances avec les réponses API.

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

Questions fréquemment posées

Y a-t-il un niveau gratuit pour l'API ? Vos 50 crédits d'inscription fonctionnent sur les appels API. C'est 6 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 les produits commerciaux ? Oui. L'utilisation commerciale est incluse. Les images générées par vos clients leur appartiennent pour toute utilisation légitime.

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

Comment gérer les erreurs de politique de contenu ? Implémentez des messages visibles par l'utilisateur qui expliquent que le prompt a été rejeté. Enregistrez l'erreur spécifique pour le débogage.

Que se passe-t-il si mes crédits s'épuisent au milieu d'une requête ? L'API retourne une erreur 402 avant le début de la génération. Les frais partiels ne se produisent jamais : vous obtenez l'image complète ou une erreur.

Puis-je regrouper 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 IA prête pour la production avec un tarif prévisible par 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 les questions ou les tarifs en volume, contactez-nous via votre tableau de bord de compte.

Commencez l'intégration aujourd'hui. Obtenez votre clé API → | Voir la tarification complète → | Lire le guide v4.5 →