Seedream v4.5 API: integrera AI-bilder i din app

Att integrera AI-bildgenerering i din app brukade innebära att välja mellan tre dåliga alternativ: kör Stable Diffusion själv (dyr infrastruktur), betala OpenAI per token (oförutsägbara kostnader) eller binda dig till ett prenumerations-API (slösad kapacitet). Seedream v4.5 API är byggt på ett annat sätt, betala per bild för $0.10, standard REST och svarstider på några sekunder. Den här guiden tar dig från noll till första generationen på under 10 minuter.

Vad API:et passar till

Seedream v4.5 API passar applikationer som behöver AI-bildgenerering på begäran med förutsägbara kostnader per bild. Vanliga användningsområden:

SaaS-produkter som låter användare generera bilder som en del av sitt arbetsflöde, till exempel designverktyg, marknadsföringsplattformar och appar för innehållsskapande.

E-handelsplattformar som programmatiskt genererar livsstilsbilder för produkter eller kategorihuvuden.

Marknadsföringsautomation som producerar kampanjbilder baserade på strukturerade indata.

Innehållshanteringssystem som erbjuder AI-bildgenerering som en inbyggd funktion.

Utvecklarprojekt och automationsskript för arbetsflöden som behöver bildgenerering i stor skala.

Mobilappar som anropar API:et från en backend-tjänst för att hålla bildgenereringen utanför enheten.

Om ditt användningsområde matchar något av dessa kommer den här guiden att hjälpa dig att integrera snabbt.

Autentisering och kom igång

Steg 1: Skaffa en API-nyckel

Registrera dig för ett Arteza-konto om du inte redan har ett. Gå till dina kontoinställningar och generera en API-nyckel. Behandla den här nyckeln som ett lösenord, committa den inte till publika repositorier.

Steg 2: Lägg till krediter på ditt konto

API-användning dras från samma kreditbalans som webbgränssnittet. Dina 10 gratis registreringskrediter fungerar även för API-anrop. För produktionsanvändning, prenumerera via prissida från $5.

Steg 3: Gör din första förfrågan

API-endpointen för Seedream v4.5 är:

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

Minsta förfrågningskropp:

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

Inkludera din API-nyckel i Authorization-headern:

Authorization: Bearer YOUR_API_KEY

Fullständig parameterreferens

Upplösningar som stöds

Seedream v4.5 stöder flera upplösningsalternativ upp till 4 megapixlar:

Kodexempel

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

// Användning
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']]

# Användning
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
}

Svarsformat

Lyckade svar returnerar JSON med följande 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-URL:er är giltiga i 24 timmar. Ladda ner och spara bilder omedelbart om du behöver permanent åtkomst.

Vill du ha den här detaljnivån? Prova Seedream v4.5 gratis →

Redo att börja integrera? Hämta din API-nyckel →

Felhantering

API:et returnerar standard HTTP-statuskoder:

Exempelsvar vid fel:

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

Implementera alltid felhantering och återförsök för 429- och 500-fel. Försök inte igen med 400- och 401-fel, de kräver att själva förfrågan korrigeras.

Bästa praxis för produktionsanvändning

Hastighetsbegränsning

Standardgränser för hastighet tillåter rimligt produktionsflöde. Om du behöver högre gränser, kontakta support med information om ditt användningsfall.

Implementera exponentiell backoff vid 429-fel:

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

Kredithantering

Övervaka fältet credits_remaining i varje svar. Ställ in aviseringar när saldot sjunker under ett visst tröskelvärde så att du kan fylla på innan produktionstrafiken når noll krediter.

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

Asynkron hantering

För användarvända applikationer, behandla bildgenerering som asynkront. Blockera inte UI-tråden på ett API-anrop som tar 5-15 sekunder. Mönster att följa:

• Returnera ett jobb-ID omedelbart och polla efter slutförande
• Använd webhooks (om det stöds) för notifieringar om slutförande
• Generera spekulativt i bakgrunden och cacha resultaten

Cachning

Genererade bilder är deterministiska givet samma prompt och seed. Cacha aggressivt efter prompt-hash för att undvika att generera om identiska bilder.

import hashlib

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

Promptsäkerhet

Om din app exponerar promptar för slutanvändare, implementera innehållsfiltrering innan du skickar till API:et. Arteza har innehållspolicyer, promptar som bryter mot dem returnerar fel, vilket slösar krediter och skapar misslyckanden i användargränssnittet.

Prissättning för API-användning

API-användning dras från ditt kontos kreditbalans till samma kostnad som webbgränssnittet.

Krediter kommer från samma prisnivåer oavsett om du använder dem via webben eller API:et:

• Starter: $5 = 60 krediter i månaden = 60 bilder
• Creator: $25 = 300 krediter i månaden = 300 bilder
• Pro: $50 = 700 krediter i månaden = 700 bilder
• Studio: $120 = 1 800 krediter i månaden = 1 800 bilder

Kunder med högre volym kan kontakta support om volymprissättning för kontinuerlig användning över 100 000 bilder per månad.

Kombinera med andra Arteza-modeller

Din applikation kan använda flera Seedance-modeller via samma API genom att ändra parametern model:

• seedream-v4-5 - 1 krediter - flaggskeppskvalitet
• seedream-v3 - 1 kredit - snabbare och enklare
• seedream-5-lite - 1 kredit - djuptänkande läge
• seedream-5-edit - 1 kredit - bildredigering
• seedance-2 - videogenerering (annan endpoint)

För applikationer som behöver redigeringsfunktioner utöver generering hanterar seedream-5-edit textbaserad bildredigering. Se Seedream 5 Edit-dokumentation för detaljer.

Säkerhetsöverväganden

Exponera aldrig API-nycklar på klientsidan. Dirigera alltid API-anrop via din backend. Exponerade nycklar kan användas för att tömma ditt kreditbalans.

Rotera nycklar regelbundet. Om en nyckel komprometteras, återkalla den och generera en ny.

Logga förfrågningar för felsökning. Inkludera förfrågnings-ID i dina loggar så att du kan korrelera fel med API-svar.

Implementera användningskvoter per användare. Om din app erbjuder AI-generering som en funktion, begränsa förbrukningen per användare för att förhindra missbruk.

Vanliga frågor

Finns det ett gratisnivå för API:et? Dina 10 registreringskrediter fungerar för API-anrop. Det ger 10 gratis Seedream v4.5-genereringar för att testa integrationen innan du betalar.

Vad är den typiska svarstiden? 5-15 sekunder för Seedream v4.5 beroende på upplösning och aktuell belastning.

Kan jag använda API:et för kommersiella produkter? Ja. Kommersiell användning är inkluderad. Dina kunders genererade bilder tillhör dem och kan användas för vilket legitimt syfte som helst.

Finns det ett Python SDK? Officiella SDK:er är under utveckling. Det nuvarande REST API fungerar sömlöst med vanliga HTTP-bibliotek i vilket programmeringsspråk som helst.

Hur hanterar jag fel vid innehållspolicy? Implementera användarvända meddelanden som förklarar att prompten avvisades. Logga det specifika felet för felsökning.

Vad händer om mina krediter tar slut mitt i en förfrågan? API:et returnerar ett 402-fel innan genereringen startar. Delvisa avgifter förekommer aldrig, du får antingen den fullständiga bilden eller ett fel.

Kan jag köra flera promptar i en enda förfrågan? Inte direkt. Använd num_images: 6 för att få varianter av samma prompt, eller gör parallella API-anrop för olika promptar.

---

Seedream v4.5 API ger dig produktionsfärdig AI-bildgenerering till förutsägbart pris per bild med standard REST-konventioner. För de flesta integrationer kan du gå från API-nyckel till första fungerande generering på under 10 minuter. Kontakta oss via din kontodashboard för frågor eller volymprissättning.

Börja integrera idag. Hämta din API-nyckel → | Visa fullständiga priser → | Läs v4.5-guiden →