Seedream v4.5 API: KI-Bilder in deine App integrieren

Die Integration von KI-Bildgenerierung in deine App bedeutete früher, zwischen drei schlechten Optionen zu wählen: Stable Diffusion selbst betreiben (teure Infrastruktur), OpenAI-Preise pro Token zahlen (unvorhersehbare Kosten) oder sich an eine Abo-API binden (verschwendete Kapazität). Die Seedream v4.5 API ist anders aufgebaut: Zahlung pro Bild zu je 0,10 Dollar, Standard-REST und Antwortzeiten in Sekunden. Diese Anleitung bringt dich in unter 10 Minuten von null zur ersten Generierung.

Kurzfassung

• Die Seedream v4.5 API kostet 1 Credits ($0,10) pro Bild
• Standard-REST-API mit JSON-Anfragen und -Antworten
• Parameter: Prompt, Auflösung, Seitenverhältnis, num_images (1-6), Guidance Scale
• Typische Antwortzeit: 5-15 Sekunden pro Generierung
• Tarife ab 5 Dollar pro Monat - Credits werden nur beim Generieren verbraucht

Wofür die API geeignet ist

Die Seedream v4.5 API eignet sich für Anwendungen, die eine bedarfsgesteuerte KI-Bildgenerierung mit vorhersehbaren Kosten pro Bild benötigen. Typische Anwendungsfälle:

SaaS-Produkte, die es Nutzern ermöglichen, Bilder als Teil ihres Workflows zu generieren: Design-Tools, Marketing-Plattformen, Content-Creation-Apps.

E-Commerce-Plattformen, die programmatisch Produktbilder im Lifestyle-Stil oder Kategorie-Header erstellen.

Marketing-Automatisierungs-Tools, die auf Basis strukturierter Eingaben Kampagnenvisuals erzeugen.

Content-Management-Systeme, die KI-Bildgenerierung als native Funktion anbieten.

Entwicklerprojekte und Automatisierungsskripte für jeden Workflow, der Bildgenerierung in großem Umfang benötigt.

Mobile Apps, die die API über einen Backend-Service aufrufen, um die Bildgenerierung vom Gerät fernzuhalten.

Wenn dein Anwendungsfall einem dieser Szenarien entspricht, hilft dir diese Anleitung bei einer schnellen Integration.

Authentifizierung und erste Schritte

Schritt 1: API-Schlüssel besorgen

Registrieren für ein Arteza-Konto, falls du noch keines hast. Gehe zu deinen Kontoeinstellungen und erstelle einen API-Schlüssel. Behandle diesen Schlüssel wie ein Passwort: Übertrage ihn niemals in öffentliche Repositories.

Schritt 2: Credits zum Konto hinzufügen

Die API-Nutzung zieht vom selben Credit-Guthaben wie die Web-Nutzung ab. Deine 10 kostenlosen Anmelde-Credits funktionieren auch für API-Aufrufe. Für den Produktiveinsatz kannst du über Preisseite ab 5 Dollar abonnieren.

Schritt 3: Erste Anfrage senden

Der API-Endpunkt für Seedream v4.5 lautet:

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

Minimaler Anfrage-Body:

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

Füge deinen API-Schlüssel im Authorization-Header ein:

Authorization: Bearer YOUR_API_KEY

Vollständige Parameterreferenz

Unterstützte Auflösungen

Seedream v4.5 unterstützt mehrere Auflösungsoptionen bis zu 4 Megapixeln:

Code-Beispiele

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

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

# Verwendung
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
}

Antwortformat

Erfolgreiche Antworten liefern JSON mit dieser Struktur:

{
  "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
}

Bild-URLs sind 24 Stunden lang gültig. Lade Bilder sofort herunter und speichere sie, wenn du dauerhaften Zugriff benötigst.

Möchtest du so viel Detail? Seedream v4.5 kostenlos testen →

Bereit, mit der Integration zu beginnen? API-Schlüssel holen →

Fehlerbehandlung

Die API gibt Standard-HTTP-Statuscodes zurück:

Beispiel einer Fehlerantwort:

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

Implementiere immer Fehlerbehandlung und Wiederholungsversuche für 429- und 500-Fehler. Versuche 400- und 401-Fehler nicht erneut: Diese erfordern eine Korrektur der Anfrage selbst.

Best Practices für den Produktiveinsatz

Rate-Limiting

Die standardmäßigen Rate-Limits ermöglichen einen sinnvollen Produktionsdurchsatz. Wenn du höhere Limits benötigst, wende dich mit deinen Anforderungen an den Support.

Implementiere exponentielles Backoff bei 429-Fehlern:

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")

Credit-Management

Überwache das Feld credits_remaining in jeder Antwort. Richte Benachrichtigungen ein, wenn das Guthaben unter einen Schwellenwert fällt, damit du aufstocken kannst, bevor der Produktionsbetrieb auf null Credits trifft.

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

Asynchrone Verarbeitung

Behandle die Bildgenerierung bei nutzerseitigen Anwendungen als asynchronen Vorgang. Blockiere den UI-Thread nicht für einen 5-15 Sekunden dauernden API-Aufruf. Mögliche Ansätze:

• Sofort eine Job-ID zurückgeben und den Abschluss abfragen
• Webhooks (sofern unterstützt) für Abschlussbenachrichtigungen verwenden
• Spekulativ im Hintergrund generieren und Ergebnisse cachen

Caching

Generierte Bilder sind bei gleichem Prompt und gleichem Seed deterministisch. Nutze aggressives Caching anhand des Prompt-Hashs, um das erneute Generieren identischer Bilder zu vermeiden.

import hashlib

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

Prompt-Sicherheit

Wenn deine App Nutzern das Eingeben von Prompts ermöglicht, implementiere eine Inhaltsfilterung, bevor die Anfrage an die API gesendet wird. Arteza hat Inhaltsrichtlinien: Prompts, die dagegen verstoßen, führen zu Fehlern, wodurch Credits verschwendet werden und nutzerseitige Fehler entstehen.

Preise für die API-Nutzung

Die API-Nutzung zieht vom Credit-Guthaben deines Kontos zum selben Preis wie die Web-Nutzung ab.

Credits stammen aus demselben Preisstufen, unabhängig davon, ob du sie über das Web oder die API verwendest:

• Starter: 5 Dollar = 60 Credits pro Monat = 60 Bilder
• Creator: 25 Dollar = 300 Credits pro Monat = 300 Bilder
• Pro: 50 Dollar = 700 Credits pro Monat = 700 Bilder
• Studio: 120 Dollar = 1.800 Credits pro Monat = 1.800 Bilder

Kunden mit höherem Volumen können sich wegen Mengenpreisen für eine dauerhafte Nutzung über 100.000 Bilder pro Monat an den Support wenden.

Kombination mit anderen Arteza-Modellen

Deine Anwendung kann mehrere Seedance-Modelle über dieselbe API nutzen, indem du den Parameter model änderst:

• seedream-v4-5 - 1 Credits - Flaggschiff-Qualität
• seedream-v3 - 1 Credit - schneller, schlanker
• seedream-5-lite - 1 Credit - Deep-Thinking-Modus
• seedream-5-edit - 1 Credit - Bildbearbeitung
• seedance-2 - Videogenerierung (anderer Endpunkt)

Für Anwendungen, die neben der Generierung auch Bearbeitungsfunktionen benötigen, übernimmt seedream-5-edit die textbasierte Bildbearbeitung. Weitere Details findest du in der Seedream 5 Edit-Dokumentation.

Sicherheitshinweise

Niemals API-Schlüssel clientseitig preisgeben. Leite API-Aufrufe immer über dein Backend. Offengelegte Schlüssel können genutzt werden, um dein Credit-Guthaben zu erschöpfen.

Schlüssel regelmäßig rotieren. Wenn ein Schlüssel kompromittiert wurde, widerrufe ihn und erstelle einen neuen.

Anfragen für das Debugging protokollieren. Füge Request-IDs in deine Logs ein, damit du Fehler mit API-Antworten korrelieren kannst.

Nutzungskontingente pro Nutzer implementieren. Wenn deine App KI-Generierung als Funktion anbietet, begrenze den Verbrauch pro Nutzer, um Missbrauch zu verhindern.

Häufig gestellte Fragen

Gibt es ein kostenloses Kontingent für die API? Deine 10 Anmelde-Credits funktionieren auch für API-Aufrufe. Das sind 10 kostenlose Seedream v4.5-Generierungen, um die Integration zu testen, bevor du zahlst.

Wie lang ist die typische Antwortzeit? 5-15 Sekunden für Seedream v4.5, je nach Auflösung und aktueller Last.

Kann ich die API für kommerzielle Produkte nutzen? Ja. Kommerzielle Nutzung ist eingeschlossen. Die von deinen Kunden generierten Bilder gehören ihnen und dürfen für jeden legitimen Zweck verwendet werden.

Gibt es ein Python-SDK? Offizielle SDKs sind in Entwicklung. Die aktuelle REST-API funktioniert problemlos mit Standard-HTTP-Bibliotheken in jeder Sprache.

Wie gehe ich mit Verstößen gegen die Inhaltsrichtlinien um? Implementiere nutzerseitige Meldungen, die erklären, dass der Prompt abgelehnt wurde. Protokolliere den genauen Fehler für das Debugging.

Was passiert, wenn meine Credits mitten in einer Anfrage aufgebraucht sind? Die API gibt einen 402-Fehler zurück, bevor die Generierung beginnt. Teilgebühren entstehen nie: Du erhältst entweder das vollständige Bild oder einen Fehler.

Kann ich mehrere Prompts in einer einzigen Anfrage bündeln? Nicht direkt. Verwende num_images: 6, um Variationen desselben Prompts zu erhalten, oder stelle für verschiedene Prompts parallele API-Aufrufe.

---

Die Seedream v4.5 API bietet dir produktionsreife KI-Bildgenerierung zu vorhersehbaren Preisen pro Bild und nach Standard-REST-Konventionen. Bei den meisten Integrationen kommst du in unter 10 Minuten vom API-Schlüssel zur ersten funktionierenden Generierung. Bei Fragen oder Anfragen zu Mengenpreisen wende dich über dein Konto-Dashboard an uns.

Starte noch heute mit der Integration. API-Schlüssel holen → | Vollständige Preisübersicht ansehen → | Den v4.5-Leitfaden lesen →