DEV Community: Emre Demir

Seedance 2.0 API 2026: Anleitung zur Nutzung

Emre Demir — Sat, 04 Apr 2026 13:06:10 +0000

TL;DR

Die Seedance 2.0 API wurde am 2. April 2026 über Volcengine Ark gestartet. Sie übermitteln eine Videoerstellungsaufgabe mit einer POST-Anfrage und fragen dann einen GET-Endpunkt ab, bis der Status "succeeded" erreicht ist. Die API unterstützt Text-zu-Video, Bild-zu-Video, Steuerung des ersten und letzten Frames, multimodale Referenzen und native Audioerzeugung. Ein 5-sekündiges 1080p-Video kostet etwa 0,93 $. Laden Sie das Video innerhalb von 24 Stunden herunter. Die URL läuft danach ab.

Hypereal AI

Hypereal AI ausprobieren

Teste Apidog heute

Einleitung

Am 2. April 2026 veröffentlichte ByteDance's Volcengine Ark Plattform die offizielle Seedance 2.0 API. Vorher war Seedance 2.0 nur über die Webkonsole nutzbar. Tutorials mit UI zeigen die alte Methode – dieser Artikel zeigt, wie man die API automatisiert und programmatisch ansteuert.

💡
Die API ist asynchron: Sie erstellen eine Aufgabe per POST, erhalten eine Aufgaben-ID und fragen dann zyklisch einen GET-Endpunkt ab, bis der Auftrag abgeschlossen ist. Apidog hilft, diesen Ablauf zu testen: POST-Übermittlung, Aufgaben-ID extrahieren, GET-Abfrage wiederholen, Ergebnis prüfen. Folgen Sie dem Apidog-Abschnitt, um die Testschritte praktisch auszuführen.

Der Artikel behandelt alle Eingabetypen, Token-basierte Kosten und typische Fehlerfälle.

Was ist Seedance 2.0?

Seedance 2.0 ist ByteDances modernes Videogenerierungsmodell auf Volcengine Ark mit den Modell-IDs doubao-seedance-2-0-260128 (Standard) und doubao-seedance-2-0-fast-260128 (schneller, geringere Qualität).

Neuerungen gegenüber 1.5:

Steuerung von erstem/letztem Frame (Sie geben beide Bilder an)
Multimodale Eingaben: Text, Bild(er), Video, Audio gemischt
Native Audioerzeugung: Sprache, Effekte, Musik, Umgebungsgeräusche
Lippensynchron in 8+ Sprachen
Kamerasteuerung per Prompt (z.B. Dolly, Tracking)
Bis zu 15 Sekunden Länge, maximal 2K Auflösung

Ausgabe: 24 fps, Seitenverhältnisse von 1:1 bis 21:9, frei wählbar.

Was sich geändert hat: Leitfaden vs. offizielle API

Frühere Anleitungen wie dieser Leitfaden vom Februar 2026 bezogen sich auf die Webkonsole. Mit der neuen API können Sie Seedance von jedem System, jeder Sprache und in automatisierten Pipelines nutzen – nicht mehr nur manuell per Web.

Voraussetzungen

Volcengine-Konto unter volcengine.com anlegen.

In der Ark-Konsole API-Schlüssel generieren:

https://console.volcengine.com/ark/region:ark+cn-beijing/apikey

API-Key als Umgebungsvariable speichern:
```
export ARK_API_KEY="your-api-key-here"
```
Jeder API-Request benötigt:
```
Authorization: Bearer YOUR_ARK_API_KEY
```

Neue Konten erhalten kostenloses Testguthaben – reicht für ca. 8x 15s-Generierungen in 1080p.

Text-zu-Video: Ihre erste Anfrage

Basis-URL:

https://ark.cn-beijing.volces.com/api/v3

POST für T2V-Aufgabe an /v1/contents/generations/tasks:

cURL-Beispiel

curl -X POST "https://ark.cn-beijing.volces.com/api/v3/contents/generations/tasks" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $ARK_API_KEY" \
  -d '{
    "model": "doubao-seedance-2-0-260128",
    "content": [
      {
        "type": "text",
        "text": "A golden retriever running through a sunlit wheat field, wide tracking shot, cinematic"
      }
    ],
    "resolution": "1080p",
    "ratio": "16:9",
    "duration": 5,
    "watermark": false
  }'

Antwort:

{"id": "cgt-2025xxxxxxxx-xxxx"}

Python-Beispiel (offizielles SDK)

SDK installieren:

pip install volcenginesdkarkruntime

Aufgabe senden:

import os
from volcenginesdkarkruntime import Ark

client = Ark(api_key=os.environ.get("ARK_API_KEY"))

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "A golden retriever running through a sunlit wheat field, wide tracking shot, cinematic"
        }
    ],
    resolution="1080p",
    ratio="16:9",
    duration=5,
    watermark=False,
)

print(resp.id)

Speichern Sie die Aufgaben-ID für das Polling.

Das asynchrone Aufgabenmuster: Senden, Abfragen, Herunterladen

Die Generierung dauert (bei 5s/1080p ca. 60–120 Sekunden). Status-Workflow:

queued -> running -> succeeded
                -> failed
                -> expired
                -> cancelled

Abfragen, bis Status ≠ queued/running.

Python-Abfrageschleife

import os
import time
import requests
from volcenginesdkarkruntime import Ark

client = Ark(api_key=os.environ.get("ARK_API_KEY"))

# Schritt 1: Aufgabe senden
resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {"type": "text", "text": "Aerial shot of a mountain lake at sunrise, slow dolly forward"}
    ],
    resolution="1080p",
    ratio="16:9",
    duration=5,
    watermark=False,
)

task_id = resp.id
print(f"Task submitted: {task_id}")

# Schritt 2: Abfragen mit exponentiellem Backoff
wait = 10
while True:
    result = client.content_generation.tasks.get(task_id=task_id)
    status = result.status
    print(f"Status: {status}")

    if status == "succeeded":
        video_url = result.content.video_url
        print(f"Video URL: {video_url}")
        break
    elif status in ("failed", "expired", "cancelled"):
        print(f"Task ended with status: {status}")
        break

    time.sleep(wait)
    wait = min(wait * 2, 60)  # maximal 60 Sekunden

# Schritt 3: Video herunterladen
if status == "succeeded":
    response = requests.get(video_url, stream=True)
    with open("output.mp4", "wb") as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)
    print("Heruntergeladen: output.mp4")

Exponentieller Backoff verhindert Überlastung, 60s als Maximum ist praxistauglich.

Bild-zu-Video (I2V): Animiertes Standbild

Fügen Sie ein image_url-Objekt zu content hinzu. Das Bild wird erster Frame.

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "The woman slowly turns her head and smiles at the camera"
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/portrait.jpg"}
        }
    ],
    ratio="adaptive",
    duration=5,
    watermark=False,
)

Mit ratio: "adaptive" übernimmt das Modell das Bildseitenverhältnis.

Max. 30 MB pro Bild
Bis zu 9 Bilder pro Anfrage

Erster und letzter Frame: Start- und Endpunkte steuern

Zwei Bilder plus Text = Animation von Bild A zu Bild B.

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "The flower blooms from bud to full open, macro lens, soft light"
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/flower-bud.jpg"}
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/flower-open.jpg"}
        }
    ],
    ratio="adaptive",
    duration=8,
    watermark=False,
)

Reihenfolge: 1. Startbild, 2. Endbild. Optional return_last_frame: true setzen, um das letzte Bild für Folgeanfragen zu erhalten.

Multimodale Referenzen: Bilder, Video, Audio kombinieren

content kann enthalten:

{"type": "text", ...} (Prompt)
{"type": "image_url", ...} (Bild)
{"type": "video_url", ...} (Video)
{"type": "audio_url", ...} (Audio)

Grenzwerte:

Bis 9 Bilder (<30 MB/Bild)
Bis 3 Videos (2–15s, <50 MB/Clip)
Bis 3 Audios (MP3, <15 MB/Datei)

Beispiel-Request:

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "Match the visual style of the reference clip and add the provided background audio"
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/style-reference.jpg"}
        },
        {
            "type": "video_url",
            "video_url": {"url": "https://example.com/motion-reference.mp4"}
        },
        {
            "type": "audio_url",
            "audio_url": {"url": "https://example.com/background-music.mp3"}
        }
    ],
    duration=10,
    ratio="16:9",
    watermark=False,
)

Mit Videoreferenz sinkt der Abrechnungssatz auf die V2V-Stufe (~3,90 $/Mio Token).

Native Audioerzeugung

Aktivieren Sie generate_audio: true, um Audio und Video gemeinsam zu generieren (inkl. Dialog, Musik, Effekte, Umgebungsgeräusche, Lippensynchronisation).

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "A street musician plays guitar outside a cafe in Paris, crowds passing by, city sounds"
        }
    ],
    resolution="1080p",
    ratio="16:9",
    duration=10,
    generate_audio=True,
    watermark=False,
)

Audio erhöht die Token-Anzahl geringfügig.

Auflösung, Seitenverhältnis und Dauer steuern

resolution: "480p", "720p", "1080p", "2K" (Standard: "1080p")
ratio: "16:9", "9:16", "4:3", "3:4", "21:9", "1:1", "adaptive"
duration: 4–15 Sekunden (Standard: 5)

Das schnelle Modell (doubao-seedance-2-0-fast-260128) ist für Prototyping, das Standardmodell für finale Produktionen.

Seedance 2.0 ist optimal, wenn Sie native Audio/Video-Co-Generierung, Frame-Kontrolle oder multimodale Referenzen benötigen. Für einfaches T2V und geringe Kosten: das schnelle Modell bei 480p verwenden.

Kosten aus der Antwort ablesen

Nach erfolgreicher Aufgabe enthält die Antwort ein usage-Feld:

{
  "usage": {
    "completion_tokens": 246840,
    "total_tokens": 246840
  }
}

15s/1080p ≈ 308.880 Token
5s/1080p ≈ 102.960 Token

Preise (T2V/I2V 1080p): 46 Yuan/Mio Token (~6,40 $/Mio Token).

Schnellübersicht:

5s 1080p: ~102.960 Token ≈ 0,93 $
10s 1080p: ~205.920 Token ≈ 1,97 $

Mit Videoreferenz (V2V): 28 Yuan/Mio Token (~3,90 $/Mio Token).

Die genaue Token-Anzahl finden Sie in der Antwort – multiplizieren Sie mit Ihrem Stufensatz, um die Kosten zu berechnen.

Wichtig: Video innerhalb von 24 Stunden herunterladen

Die video_url läuft 24h nach erfolgreicher Aufgabe ab (danach 403-Fehler). Laden Sie die Datei sofort nach Status succeeded herunter. Das Feld execution_expires_after gibt das Aufgabenzeitfenster an (z.B. 172800 Sekunden = 48h), die Video-URL ist trotzdem nur 24h gültig. Aufgabenhistorie: 7 Tage.

So testen Sie die Seedance API mit Apidog

Seedance benötigt einen mehrstufigen Testablauf. Mit Apidog können Sie das exakt abbilden.

Schritt-für-Schritt:

1. Test-Szenario anlegen

In Apidog im Testmodul ein neues Szenario „Seedance 2.0 Video-Generierung“ erstellen.
Umgebungsvariable ARK_API_KEY setzen.
In Requests {{ARK_API_KEY}} verwenden.

2. Übermittlungsanfrage

POST an https://ark.cn-beijing.volces.com/api/v3/contents/generations/tasks.
Authorization: Bearer {{ARK_API_KEY}}.
JSON-Body nach Bedarf.
Nach dem Schritt: Aufgaben-ID per JSONPath ($.id) extrahieren und als TASK_ID speichern.

3. Warte-Prozessor

Nach Extraktion: 30 Sekunden warten.

4. Abfrage in For-Schleife

For-Block, max. 20 Iterationen.
1. GET an https://ark.cn-beijing.volces.com/api/v3/contents/generations/tasks/{{TASK_ID}} mit Auth.
2. Nach GET: 10s warten.
3. Schleife abbrechen bei $.status == "succeeded" oder "failed".

5. Assertions

Nach Schleife prüfen:
- $.status == "succeeded"
- $.content.video_url nicht leer

Apidog generiert einen vollständigen Testbericht. Sie können cURL-Befehle direkt importieren, um Requests anzulegen.

Preisaufschlüsselung: Was ein 10-sekündiges Video kostet

Seedance nutzt Pay-as-you-go, keine monatlichen Lizenzen. Testguthaben für erste Experimente.

Aufgabentyp	Rate (pro 1 Mio. Token)
T2V / I2V bei 1080p	46 Yuan (~$6.40)
V2V (Video-Referenz)	28 Yuan (~$3.90)

Ungefähre Kosten bei 1080p:

Dauer	Ungefähre Token	Kosten (T2V/I2V)
5 Sekunden	~103.000	~$0.66 Yuan / ~$0.93
10 Sekunden	~206.000	~$9.48 Yuan / ~$1.32
15 Sekunden	~309.000	~$14.21 Yuan / ~$1.97

Reduzieren Sie die Auflösung für niedrigere Kosten (480p ist am günstigsten). Beginnen Sie mit 720p für Entwicklung, erhöhen Sie bei Bedarf.

Häufige Fehler und Lösungen

429 Too Many Requests

Zu viele parallele Aufgaben. Exponentiellen Backoff verwenden (Start: 10s, dann verdoppeln bis 60s).

status: "failed"

Meist wegen Sicherheitsfiltern, beschädigten/zu großen Bildern oder ungültigen Parametern. Eingaben prüfen und erneut versuchen.

status: "expired"

Aufgabe zu lange in Warteschlange. Bei Lastspitzen erneut senden.

403 bei video_url

Video-URL abgelaufen (nach 24h). Nur Lösung: neu generieren (ggf. mit gespeichertem Seed).

Seed-Reproduzierbarkeit

Seed aus Antwort speichern und bei identischen Parametern erneut übergeben, um gleiche Ausgabe zu reproduzieren.

Fazit

Die Seedance 2.0 API bietet Ihnen direkten Zugang zu fortschrittlicher Videogenerierung. Das Aufgabenmuster: POST → abfragen → sofort herunterladen. Multimodale Eingaben, native Audiogen und Frame-Steuerung ermöglichen Automatisierungen, die per Weboberfläche unmöglich wären.

Richten Sie Ihre Testflows in Apidog ein, bevor Sie in Produktion gehen – so vermeiden Sie typische Fehler bei Abfragen, Extraktion und URL-Ablauf.

FAQ

F: Was ist der Unterschied zwischen doubao-seedance-2-0-260128 und doubao-seedance-2-0-fast-260128?

A: Standardmodell = höchste Qualität, für Produktion. Fast-Modell = schneller, aber geringere Qualität. Für schnelle Prompt-Iterationen Fast-Modell, für finale Videos Standard verwenden.

F: Kann ich Seedance 2.0 außerhalb Chinas nutzen?

A: Ja, API läuft in Peking – höhere Latenz außerhalb Chinas möglich. Volcengine-Nutzungsbedingungen beachten.

F: Wie verketten ich mehrere Clips zu einem längeren Video?

A: Bei jeder Generierung return_last_frame: true setzen. Das Endbild als ersten Frame für den nächsten Clip nutzen. Finales Video mit einer Videobibliothek zusammenfügen.

F: Kostet die native Audioerzeugung mehr?

A: Ja, der Tokenverbrauch steigt moderat durch gemeinsame Audio-Video-Erzeugung.

F: Kann ich einen Webhook statt Polling nutzen?

A: Ja, mit Parameter callback_url in der POST-Anfrage. Die API ruft Ihre URL bei Statusänderung auf.

F: Was passiert, wenn ich das Limit von 9 Bildern überschreite?

A: Die API gibt einen 400-Fehler zurück. Maximal 9 Bilder pro Anfrage zulässig.

F: Garantiert der Seed-Parameter die exakte Reproduktion?

A: Erhöht Reproduzierbarkeit, garantiert aber keine 100% identische Ausgabe, falls Parameter/Modell sich ändern.

F: Wie verfolge ich die Ausgaben über mehrere Aufgaben hinweg?

A: completion_tokens aus jeder Antwort auslesen, mit aktuellem Tokenpreis multiplizieren und loggen. Ein zentrales Dashboard gibt es nicht, eigene Kostenüberwachung implementieren.

Grok Text zu Video API nutzen: Vollständige Anleitung

Emre Demir — Fri, 03 Apr 2026 08:48:54 +0000

Kurz gesagt

Die Grok Text-zu-Video API generiert Videos aus einer Textaufforderung. Sie rufen POST /v1/videos/generations auf, erhalten sofort eine request_id zurück und fragen dann GET /v1/videos/{request_id} ab, bis der Status "done" ist. Das Modell ist grok-imagine-video, die Preise beginnen bei 0,05 $ pro Sekunde bei 480p. Das xAI Python SDK übernimmt das Polling automatisch.

Teste Apidog jetzt

Einleitung

xAI generierte allein im Januar 2026 1,2 Milliarden Videos. Dies war der erste Monat nach der Einführung der Grok Text-zu-Video API am 28. Januar 2026. Das Modell belegte im selben Monat den ersten Platz in der Text-zu-Video-Bestenliste von Artificial Analysis. Diese Zahlen zeigen, dass die Infrastruktur im großen Maßstab erprobt ist.

In diesem Leitfaden lernst du Schritt für Schritt: Erste Anfrage stellen, Ergebnis abfragen, Parameter anpassen, bessere Prompts schreiben. Du erfährst außerdem, wie du Referenzbilder verwendest, bestehende Videos erweiterst oder bearbeitest und wann Text-zu-Video die richtige Wahl ist.

💡 Tipp: Die API ist asynchron. Das Frontend kann nicht warten, bis das Video fertig ist, um etwas zu rendern. Entwickle deine Video-UI mit einem Polling-Workflow – ohne jedes Mal Credits auszugeben. Mit Apidogs Smart Mock kannst du beide Endpunkte simulieren. So entwickelt das Team die UI parallel zum Backend.

Was ist die Grok Text-zu-Video API?

Die Grok Text-zu-Video API ist Teil der Mediengenerierungs-Suite von xAI unter https://api.x.ai. Du sendest einen Textprompt, das Modell grok-imagine-video generiert daraus einen neuen Videoclip. Kein Quellbild nötig.

Neben dem Text-zu-Video-Endpunkt gibt es einen synchronen Bildgenerator (POST /v1/images/generations, Modell grok-imagine-image, 0,02 $ pro Bild) sowie Endpunkte zum Erweitern und Bearbeiten von Videos.

Anders als beim Bild-zu-Video-Modus lieferst du beim Text-zu-Video nur Worte. Szene, Bewegung und Stil entstehen komplett durch die Beschreibung. Den Bild-zu-Video-Leitfaden findest du hier.

Wie die Text-zu-Video-Generierung funktioniert (das asynchrone Muster)

Die API setzt auf ein asynchrones Muster:

POST-Anfrage mit Prompt senden.
Sofortige Antwort mit request_id.
Video wird im Hintergrund generiert.
Wiederholt GET-Anfrage mit request_id senden.
Sobald status auf "done" steht, enthält die Antwort die Video-URL.

Das Frontend muss den Ladezustand anzeigen, bis das Video bereit ist.

Voraussetzungen

Vor dem Start:

xAI-Konto: Anlegen unter console.x.ai. Abrechnung aktivieren.
API-Schlüssel: In der xAI-Konsole unter "API Keys" erstellen und sicher speichern. Als Bearer-Token im Header jeder Anfrage nutzen.

API-Key als Umgebungsvariable setzen:

export XAI_API_KEY="your_api_key_here"

Optional: xAI Python SDK installieren:

pip install xai-sdk

Erste Text-zu-Video-Anfrage

Der Endpunkt: POST https://api.x.ai/v1/videos/generations

Pflichtfelder: model, prompt

Mit curl:

curl -X POST https://api.x.ai/v1/videos/generations \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "prompt": "A golden retriever running through autumn leaves in slow motion, cinematic lighting"
  }'

Antwort:

{
  "request_id": "d97415a1-5796-b7ec-379f-4e6819e08fdf"
}

Mit Python (requests):

import requests
import os

API_KEY = os.environ["XAI_API_KEY"]
BASE_URL = "https://api.x.ai"

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

payload = {
    "model": "grok-imagine-video",
    "prompt": "A golden retriever running through autumn leaves in slow motion, cinematic lighting"
}

response = requests.post(
    f"{BASE_URL}/v1/videos/generations",
    headers=headers,
    json=payload
)

data = response.json()
request_id = data["request_id"]
print(f"Generation gestartet. Request ID: {request_id}")

Videoergebnis abfragen

Mit der erhaltenen request_id wiederholt GET /v1/videos/{request_id} abfragen, bis status "done" ist.

Mögliche Statuswerte:

"processing": Wird noch generiert
"done": Abgeschlossen, Video-URL verfügbar
"failed": Fehler aufgetreten

Komplette Python-Polling-Schleife:

import requests
import time
import os

API_KEY = os.environ["XAI_API_KEY"]
BASE_URL = "https://api.x.ai"

headers = {
    "Authorization": f"Bearer {API_KEY}"
}

def poll_video(request_id: str, interval: int = 5, max_attempts: int = 60) -> dict:
    url = f"{BASE_URL}/v1/videos/{request_id}"
    for attempt in range(max_attempts):
        response = requests.get(url, headers=headers)
        data = response.json()
        status = data.get("status")
        progress = data.get("progress", 0)
        print(f"Attempt {attempt + 1}: status={status}, progress={progress}%")
        if status == "done":
            return data
        elif status == "failed":
            raise RuntimeError(f"Video generation failed: {data}")
        time.sleep(interval)
    raise TimeoutError(f"Video nicht bereit nach {max_attempts} Versuchen")

def generate_video(prompt: str) -> str:
    response = requests.post(
        f"{BASE_URL}/v1/videos/generations",
        headers={**headers, "Content-Type": "application/json"},
        json={"model": "grok-imagine-video", "prompt": prompt}
    )
    request_id = response.json()["request_id"]
    print(f"Request ID: {request_id}")
    result = poll_video(request_id)
    video_url = result["video"]["url"]
    print(f"Video bereit: {video_url}")
    return video_url

video_url = generate_video(
    "A timelapse of a city skyline at sunset transitioning to night, aerial view"
)

Typische finale Antwort:

{
  "status": "done",
  "video": {
    "url": "https://vidgen.x.ai/....mp4",
    "duration": 8,
    "respect_moderation": true
  },
  "progress": 100,
  "usage": {
    "cost_in_usd_ticks": 500000000
  }
}

xAI Python SDK verwenden

Das SDK übernimmt das Polling. Beispiel:

from xai_sdk import Client
import os

client = Client(api_key=os.environ["XAI_API_KEY"])

result = client.video.generate(
    model="grok-imagine-video",
    prompt="A golden retriever running through autumn leaves in slow motion",
    duration=8,
    resolution="720p",
    aspect_ratio="16:9"
)

print(f"Video URL: {result.video.url}")
print(f"Dauer: {result.video.duration}s")

Für maximale Kontrolle über Wiederholungen, Fortschritt und Intervall: Roh-Requests verwenden. Für produktiven Schnellstart: SDK.

Effektive Prompts für die Videogenerierung

Szenenbeschreibung: Motiv und Umgebung klar beschreiben. Beispiel: „Weiße Keramiktasse auf Holztisch neben regennassem Fenster“
Bewegung: Was bewegt sich wie? Beispiel: „Kamera umkreist langsam die Tasse, Dampf steigt auf“
Kamerastil: Begriffe wie „Nahaufnahme“, „Drohnenaufnahme“, „Handkamera“
Beleuchtung/Stimmung: „Goldene Stunde“, „Studio-Dreipunktbeleuchtung“, „neblig, melancholisch“
Stilreferenzen: „kinematisch“, „Anime“, „Stop-Motion“

Empfohlene Prompt-Struktur:

A lone astronaut floats past the International Space Station,
tether drifting behind them. The camera tracks slowly
alongside, showing Earth below. Cinematic, IMAX quality,
warm sunrise light reflecting off the visor.

Auflösung, Dauer und Seitenverhältnis steuern

Dauer:

  "duration": 10

(1–15 Sekunden, Default: 6)

Auflösung:

  "resolution": "720p"

"480p" (Default) oder "720p"

Seitenverhältnis:

  "aspect_ratio": "9:16"

| Verhältnis | Am besten für |
|------------|---------------------------|
| 16:9 | Desktop, YouTube, Präsentationen |
| 9:16 | TikTok, Instagram Reels, Mobil |
| 1:1 | Instagram Feed, Social Cards |
| 4:3 | Klassisches Video, Präsentationen|
| 3:4 | Hochformat-Apps |
| 3:2 | Standard-Fotoformat |
| 2:3 | Porträtfotografie |

Komplettes Beispiel:

curl -X POST https://api.x.ai/v1/videos/generations \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "prompt": "A coastal town at dawn, waves breaking gently on a rocky shore",
    "duration": 10,
    "resolution": "720p",
    "aspect_ratio": "16:9"
  }'

Referenzbilder zur Steuerung des Videostils

Bis zu 7 Bild-URLs im Parameter reference_images:

{
  "model": "grok-imagine-video",
  "prompt": "A coastal town at dawn, waves breaking gently on a rocky shore",
  "reference_images": [
    {"url": "https://example.com/my-style-reference.jpg"},
    {"url": "https://example.com/color-palette-reference.jpg"}
  ]
}

Wähle stilistisch konsistente Bilder für eine klare Führung. Unterschied zu Bild-zu-Video: Bei Referenzbildern bleibt die Szene prompt-gesteuert, Bilder steuern nur Look & Feel.

Generierte Videos erweitern und bearbeiten

Video erweitern:

POST /v1/videos/extensions

Übergebe die request_id des Originalvideos + neuen Prompt.
Video bearbeiten:

POST /v1/videos/edits

Passe Stil oder Inhalt per Textanweisung an.

Beide Endpunkte sind asynchron (request_id → polling mit GET /v1/videos/{request_id}).

Kosten aus der API-Antwort auslesen

Im Antwort-Objekt:

"usage": {
  "cost_in_usd_ticks": 500000000
}

Umrechnung:

cost_in_usd = result["usage"]["cost_in_usd_ticks"] / 10_000_000
print(f"Kosten: ${cost_in_usd:.4f}")
# Output: Kosten: $0.0500

Referenztabelle:

Auflösung	Preis pro Sekunde	10-Sekunden-Clip
480p	0,05 $	0,50 $
720p	0,07 $	0,70 $

Verfolge cost_in_usd_ticks zur Kostenkontrolle ohne separate Abrechnungs-API.

So testest du die Grok Video-API mit Apidog

Das asynchrone Muster verlangt, dass du Lade-, Erfolgs- und Fehlerzustände im Frontend testest – ohne echte Credits zu verbrauchen. Mit Apidogs Smart Mock simulierst du beide Endpunkte.

Use Case 1: Smart Mock für Frontend-Entwicklung

Generierungs-Endpunkt simulieren: In Apidog POST /v1/videos/generations anlegen, Antwortschema mit request_id definieren. Smart Mock erzeugt automatisch eine passende UUID.

Beispielantwort:

  {
    "request_id": "d97415a1-5796-b7ec-379f-4e6819e08fdf"
  }

Abfrage-Endpunkt simulieren: GET /v1/videos/{request_id} mit vollständigem Schema (Status, Video-URL etc.) anlegen. Mock-Antwort für "status": "done" festlegen.

Beispielantwort:

  {
    "status": "done",
    "video": {
      "url": "https://vidgen.x.ai/mock-video-12345.mp4",
      "duration": 8,
      "respect_moderation": true
    },
    "progress": 100,
    "usage": {
      "cost_in_usd_ticks": 400000000
    }
  }

Frontendentwickler können die UI gegen diese Mock-Server testen – inkl. Lade-, Erfolgs- und Fehlerzustand (z.B. "status": "failed" mocken). Keine echten API-Credits nötig.

Use Case 2: Testszenarien für die Abfrageschleife

1. Schritt:

POST /v1/videos/generations als ersten Testschritt. request_id mit JSONPath $.request_id als Variable extrahieren.
2. Schritt:

GET /v1/videos/{{videoRequestId}} als zweiten Testschritt, in einer For-Schleife mit Abbruchbedingung response.body.status == "done". Wartezeit (z.B. 5s) zwischen den Polls einbauen.
3. Schritt:

Nach Schleifenende Assertion, dass $.video.url nicht leer ist.

Dieses Testszenario lässt sich automatisiert in CI laufen – für stabile Integrationen.

Text-zu-Video vs. Bild-zu-Video: Wann welchen Modus?

Beide nutzen das Modell grok-imagine-video, aber die Anwendung unterscheidet sich:

Text-zu-Video, wenn:

Originelle Inhalte aus Konzept/Skript generiert werden sollen
Das Modell volle kreative Kontrolle haben soll
User Prompts eingeben
Kein Quellbild vorhanden ist

Bild-zu-Video, wenn:

Produktfotos, Illustrationen, Assets animieren
Konkrete Bilddetails erhalten bleiben sollen
Konsistente Animationen aus Bilderserien gebraucht werden
Eigene Kunstwerke/Fotos animiert werden sollen

Text-zu-Video = Szene aus Prompt.

Bild-zu-Video = Bild wird animiert.

Vollständigen Bild-zu-Video-Leitfaden siehe hier.

Häufige Fehler und Lösungen

401 Unauthorized: API-Schlüssel fehlt, abgelaufen oder falsch. Authorization-Header prüfen: Bearer YOUR_XAI_API_KEY (ohne Leerzeichen am Ende), Schlüssel in der Konsole aktiv?
429 Too Many Requests: Ratenlimit erreicht (60/min, 1/sec). Abfrageintervall erhöhen, mindestens 5s zwischen Polls.
status: "failed": Prompt von Inhaltsmoderation abgelehnt. Siehe Feld respect_moderation. Prompt präzisieren, keine sensiblen Begriffe.
Video-URL 404: URLs sind temporär, Video direkt nach Erhalt herunterladen und selbst speichern.
Leeres/eingefrorenes Video: Zu vage oder ohne Bewegungshinweise. Prompt um klare Bewegungsanweisungen ergänzen.
Lange Wartezeiten: 720p und lange Clips dauern länger. Für Entwicklung 480p und kurze Clips nutzen.

Fazit

Die Grok Text-zu-Video API bietet einen klaren Weg von Prompt zu Video: Anfrage, request_id, Polling, MP4-Download. Das asynchrone Abfragemuster ist der Kern. Wenn die Polling-Logik steht, kannst du Dauer, Auflösung, Seitenverhältnis und Referenzbilder gezielt optimieren.

Für Produktionsbuilds: Kostenverfolgung via cost_in_usd_ticks jeder Antwort. Simuliere die Endpunkte mit Apidog, damit das Frontend unabhängig vom Backend entwickelt werden kann. Automatisiere Testszenarien für stabile Integrationen.

FAQ

Welchen Modellnamen verwende ich für die Text-zu-Video-Generierung?

grok-imagine-video ist das erforderliche model-Feld für POST /v1/videos/generations.

Wie lange dauert die Videogenerierung?

Je nach Dauer/Auflösung. Kurze 480p-Clips: <30s, lange 720p-Clips: mehrere Minuten. Poll alle 5–10 Sekunden.

Kann ich Videos länger als 15 Sekunden generieren?

Nicht in einer Anfrage. Maximal duration: 15. Für längere Videos: Clip generieren, dann mit POST /v1/videos/extensions erweitern.

Wie lade ich das Video herunter?

Nutze die URL aus result.video.url der fertigen Antwort. MP4 direkt downloaden, URL ist temporär.

Was passiert, wenn der Prompt moderiert wird?

Status bleibt failed, Feld respect_moderation zeigt Moderation an. Prompt anpassen und erneut versuchen.

Gibt es eine kostenlose Stufe?

xAI berechnet pro generierter Sekunde. Keine Gratisstufe für Videos. Ggf. aktuelle Aktionen in console.x.ai prüfen.

Unterschied zwischen reference_images und Quellbild?

reference_images steuern Stil bei Text-zu-Video. Sie beeinflussen die Optik, werden aber kein direktes Motiv. Beim Bild-zu-Video wird das Bild der Startframe.

Wie teste ich Polling ohne Credits?

Mit Apidogs Smart Mock beide Endpunkte simulieren. Schemata definieren, Mock-Antworten für "processing" und "done" anlegen – dein Polling-Code funktioniert dann ohne echte API.

Grok Image zu Video API nutzen: Schritt-für-Schritt Anleitung

Emre Demir — Fri, 03 Apr 2026 08:43:11 +0000

TL;DR

Die Grok Bild-zu-Video API nutzt das Modell grok-imagine-video, um ein statisches Bild in einen animierten Videoclip zu verwandeln. Sende per POST deine Bild-URL, einen Prompt und optionale Einstellungen an https://api.x.ai/v1/videos/generations. Die API gibt sofort eine request_id zurück. Anschließend mit GET /v1/videos/{request_id} abfragen, bis status auf "done" steht. Die Dauer liegt zwischen 1 und 15 Sekunden. Preise starten ab 0,05 $ pro Sekunde für 480p-Ausgabe.

Probiere Apidog jetzt aus

Einführung

Am 28. Januar 2026 veröffentlichte xAI das Modell grok-imagine-video für den öffentlichen API-Zugang. Im ersten Monat generierte das Modell 1,2 Milliarden Videos und führte das Artificial Analysis Text-zu-Video-Leaderboard an. Die Bild-zu-Video-Funktion erlaubt es, ein Foto und einen Prompt zu senden, woraufhin die API das Bild in einen animierten Videoclip (MP4) verwandelt.

Für die Integration ist wichtig: Die API arbeitet asynchron. Ein erfolgreicher POST mit Status 200 reicht nicht – die Integration ist erst abgeschlossen, wenn deine Abfrageschleife die Zustände "processing", "done" und "failed" korrekt verarbeitet.

Mit Apidog kannst du Test-Szenarien für diese asynchronen Workflows direkt umsetzen: Sende POST an /v1/videos/generations, extrahiere die request_id, wiederhole GET bis status == "done", und prüfe, ob die Video-URL vorhanden ist.

Was ist die Grok Bild-zu-Video API?

Die Grok Bild-zu-Video API ist Teil des Videoerstellungsprodukts von xAI. Sie basiert auf dem Modell grok-imagine-video und akzeptiert ein Bild als Startrahmen des Ausgabevideos. Das Modell analysiert Bildinhalt und Prompt und erzeugt natürliche Bewegung, um die Szene zu animieren.

API-Endpunkt:

POST https://api.x.ai/v1/videos/generations

Authentifizierung:

Authorization: Bearer YOUR_XAI_API_KEY

Den Schlüssel erhältst du in der xAI-Konsole. Die API unterstützt auch Text-zu-Video (ohne image), Videoerweiterungen und Bearbeitungen.

Wie der Bild-zu-Video-Prozess funktioniert

Der Parameter image im Request bezeichnet den ersten Frame des Videos. Das Modell ersetzt das Bild nicht, sondern startet damit. Jeder Pixel des ersten Frames stammt aus deinem Quellbild. Das Modell prognostiziert, wie sich die Szene gemäß Prompt entwickeln würde.

Beispiel:

Bild: Bergsee bei Sonnenaufgang.

Prompt: "Sanfte Wellen breiten sich über das Wasser aus, während morgendlicher Nebel aufzieht."

Der erste Frame ist dein Foto. Die Folgebilder zeigen animiertes Wasser und Nebel.

Wann Bild-zu-Video verwenden?

Du hast ein bestehendes Foto, das animiert werden soll.
Markenidentität fordert einen festen Startframe.
Bewegung soll an eine reale Szene gebunden sein.

Wann Text-zu-Video verwenden?

Keine Referenzbilder vorhanden.
Komplette Szenengenerierung dem Modell überlassen.
Schnelle Iteration wichtiger als Frame-Präzision.

Voraussetzungen

Vor dem ersten API-Aufruf benötigst du:

xAI-Konto: console.x.ai
API-Key aus der xAI-Konsole (als Umgebungsvariable speichern)
Python 3.8+ oder Node.js 18+ (Beispiele für beide)
Öffentlich erreichbare Bild-URL oder base64-kodiertes Bild (Data-URI)

API-Key setzen:

export XAI_API_KEY="your_key_here"

xAI Python SDK installieren (optional):

pip install xai-sdk

Für reine HTTP-Aufrufe reichen requests (Python) oder fetch (Node.js).

Erste Bild-zu-Video-Anfrage

Mit curl

curl -X POST https://api.x.ai/v1/videos/generations \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "prompt": "Gentle waves move across the surface, morning mist rises slowly",
    "image": {
      "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/1/1a/24701-nature-natural-beauty.jpg/1280px-24701-nature-natural-beauty.jpg"
    },
    "duration": 6,
    "resolution": "720p",
    "aspect_ratio": "16:9"
  }'

Antwort:

{
  "request_id": "d97415a1-5796-b7ec-379f-4e6819e08fdf"
}

Das Video wird jetzt asynchron generiert – abfragen nicht vergessen!

Mit Python (raw requests)

import os
import requests

api_key = os.environ["XAI_API_KEY"]

payload = {
    "model": "grok-imagine-video",
    "prompt": "Gentle waves move across the surface, morning mist rises slowly",
    "image": {
        "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/1/1a/24701-nature-natural-beauty.jpg/1280px-24701-nature-natural-beauty.jpg"
    },
    "duration": 6,
    "resolution": "720p",
    "aspect_ratio": "16:9"
}

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json"
}

response = requests.post(
    "https://api.x.ai/v1/videos/generations",
    json=payload,
    headers=headers
)

data = response.json()
request_id = data["request_id"]
print(f"Job started: {request_id}")

Base64-Bild verwenden

Wenn das Bild lokal ist, als Data-URI kodieren:

import base64

with open("my_image.jpg", "rb") as f:
    encoded = base64.b64encode(f.read()).decode("utf-8")

payload["image"] = {
    "url": f"data:image/jpeg;base64,{encoded}"
}

Abfragen des Ergebnisses

Die Videoerstellung ist asynchron. Status abfragen mit:

GET https://api.x.ai/v1/videos/{request_id}

Statuswerte:

Status	Bedeutung
`"processing"`	Video wird noch gerendert
`"done"`	Video fertig, URL in der Antwort
`"failed"`	Fehler aufgetreten

Abgeschlossene Antwort:

{
  "status": "done",
  "video": {
    "url": "https://vidgen.x.ai/....mp4",
    "duration": 6
  },
  "progress": 100
}

Komplette Python-Abfrageschleife

import time

def poll_video(request_id: str, api_key: str, interval: int = 5) -> dict:
    url = f"https://api.x.ai/v1/videos/{request_id}"
    headers = {"Authorization": f"Bearer {api_key}"}

    while True:
        response = requests.get(url, headers=headers)
        data = response.json()
        status = data.get("status")

        print(f"Status: {status} | Progress: {data.get('progress', 0)}%")

        if status == "done":
            return data["video"]
        elif status == "failed":
            raise RuntimeError(f"Video generation failed for {request_id}")

        time.sleep(interval)

# Verwendung
video = poll_video(request_id, api_key)
print(f"Video URL: {video['url']}")
print(f"Duration: {video['duration']}s")

Tipp: Polling-Intervall auf 5 Sekunden oder länger setzen (Ratenlimit: 60 Anfragen/Minute).

xAI Python SDK verwenden

Mit xai-sdk übernimmt das SDK das asynchrone Polling automatisch:

from xai_sdk import Client
import os

client = Client(api_key=os.environ["XAI_API_KEY"])

video = client.video.generate(
    model="grok-imagine-video",
    prompt="Gentle waves move across the surface, morning mist rises slowly",
    image={"url": "https://example.com/landscape.jpg"},
    duration=6,
    resolution="720p",
    aspect_ratio="16:9"
)

print(f"Video URL: {video.url}")
print(f"Duration: {video.duration}s")

Das SDK kümmert sich um Polling, Statusprüfungen und Fehler. Für detailliertere Kontrolle empfiehlt sich der Raw-Requests-Ansatz.

Auflösung, Dauer und Seitenverhältnis steuern

Dauer:

duration akzeptiert Werte von 1 bis 15 Sekunden (Standard: 6).

"duration": 10

Längere Videos erhöhen die Kosten linear.

Auflösung:

Wert	Beschreibung
`"480p"`	Standard. Günstiger, schneller
`"720p"`	Höhere Qualität, teurer

"resolution": "720p"

Seitenverhältnis (aspect_ratio):

Wert	Anwendungsfall
`"16:9"`	Standard, Landschaft
`"9:16"`	Vertikal, Social Stories
`"1:1"`	Quadrat, Instagram
`"4:3"`	Klassisch, Präsentation
`"3:4"`	Portrait
`"3:2"`	Foto-Zuschnitt
`"2:3"`	Hochformat Portrait

Standardmäßig wird das Seitenverhältnis an das Quellbild angepasst. Zum Überschreiben explizit angeben.

Referenzbilder zur Stilführung nutzen

Der Parameter reference_images ergänzt das Hauptbild:

image: Startframe, wird animiert.
reference_images: Bis zu 7 Bilder zur Stil-/Inhaltsführung. Diese beeinflussen Look und Bewegung, erscheinen aber nicht direkt im Video.

Beispiel:

{
  "model": "grok-imagine-video",
  "prompt": "A product rotating slowly on a clean white surface",
  "image": {
    "url": "https://example.com/product-shot.jpg"
  },
  "reference_images": [
    {"url": "https://example.com/brand-style-reference-1.jpg"},
    {"url": "https://example.com/lighting-reference.jpg"}
  ],
  "duration": 6,
  "resolution": "720p"
}

Auch ohne image kannst du Referenzbilder für Text-zu-Video nutzen.

Videos erweitern und bearbeiten

Video erweitern:

Nutze POST /v1/videos/extensions, um einen Clip zu verlängern (je Aufruf max. 15 Sekunden):

curl -X POST https://api.x.ai/v1/videos/extensions \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "video_id": "your_original_request_id",
    "prompt": "The mist continues to lift as sunlight breaks through",
    "duration": 5
  }'

Ergebnis wie gewohnt mit GET /v1/videos/{request_id} abfragen.

Video bearbeiten:

Mit POST /v1/videos/edits gezielt Aspekte ändern:

curl -X POST https://api.x.ai/v1/videos/edits \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "video_id": "your_original_request_id",
    "prompt": "Change the sky to a dramatic sunset with deep orange tones"
  }'

Auch hier: asynchrones Abfragemuster nutzen.

Preisübersicht: Kosten eines 10-Sekunden-Videos

xAI berechnet:

Eingabebild: 0,002 $ pro Bild
Ausgabe 480p: 0,05 $/Sekunde
Ausgabe 720p: 0,07 $/Sekunde

Beispiel: 10 Sek. bei 720p

Eingabebild: 0,002 $
Ausgabe: 10 × 0,07 $ = 0,70 $
Gesamt: 0,702 $

Beispiel: 6 Sek. bei 480p

Eingabebild: 0,002 $
Ausgabe: 6 × 0,05 $ = 0,30 $
Gesamt: 0,302 $

Die Bildgebühr fällt immer an, auch bei wiederverwendeter URL. Text-zu-Video (ohne image) entfällt die Bildgebühr.

Grok Video API Integration mit Apidog testen

Asynchrone Workflows können mit Apidog automatisiert getestet werden:

Neues Test-Szenario:

Im Apidog "Tests"-Modul auf + klicken, z.B. "Grok Bild-zu-Video asynchroner Workflow".
Generierungsanfrage:

POST-Anforderung wie oben beschrieben anlegen.
request_id extrahieren:

Variablenextraktion (JSONPath $.request_id) auf die Antwort.
Abfrageschleife:

For-Schleifenprozessor mit GET auf /v1/videos/{{video_request_id}}, Status extrahieren, nach jedem GET 5000 ms warten.

Schleife beenden, wenn {{video_status}} == "done".
Video-URL bestätigen:

Nach der Schleife GET auf das Ergebnis, Assertion: $.video.url ist nicht leer.

Szenario ausführen:

Auf "Ausführen" klicken. Apidog führt alle Schritte durch und zeigt die Ergebnisse an.

CI/CD-Integration:

apidog run --scenario grok-video-async-flow --env production

Weitere Details zum Testen asynchroner APIs mit Apidog findest du im Leitfaden auf apidog.com.

Häufige Fehler und Behebungen

401 Unauthorized:

API-Key prüfen, Syntax des Headers beachten, Key in Konsole aktivieren.
422 Unprocessable Entity:

Felder wie model, prompt oder image.url prüfen. Bild-URL vorher testen.
Bild-URL nicht zugänglich:

Nur öffentliche URLs oder Data-URIs verwenden.
Status bleibt auf "processing":

Warten (bis zu mehrere Minuten möglich). Nach 10 Minuten ggf. neuen Job starten.
Ratenlimit (429):

Max. 60 Anfragen/Minute beachten. Polling mit Delay ausstatten.
Base64-Upload abgelehnt:

Korrektes MIME-Präfix verwenden, z.B. data:image/jpeg;base64,.
Seitenverhältnis-Fehler:

Seitenverhältnis an das Quellbild anpassen, um Zuschnitt/Letterboxing zu vermeiden.

Fazit

Mit der Grok Bild-zu-Video API bringst du Fotos schnell und automatisiert in Bewegung. Der Workflow: POST mit Bild und Prompt, request_id abfragen, GET bis fertig, MP4-URL extrahieren. Das Modell grok-imagine-video ist leistungsstark und skalierbar.

Asynchrone Abläufe sind die häufigste Fehlerquelle – teste deshalb mit Apidogs Szenarien: Variablenextraktion, Polling mit Abbruch-Bedingung, finale Assertion. So verhinderst du Integrationsfehler vor dem Go-Live.

Beginne kostenlos mit der Entwicklung deiner Integration mit Apidog. Keine Kreditkarte erforderlich.

FAQ

Welcher Modellname für die Bild-zu-Video API?

grok-imagine-video – im Feld model angeben.

Unterschied zwischen image und reference_images?

image ist der Startframe, reference_images steuern Stil und Kontext, erscheinen aber nicht als Frame. Beide kombinierbar.

Wie lange dauert die Videoerstellung?

6 Sek. 480p: meist 1–3 Minuten. 15 Sek. 720p: 4–8 Minuten. Alle 5 Sek. abfragen.

Lokale Datei als Bild?

Ja, als Data-URI kodieren: data:image/jpeg;base64,{encoded_bytes}.

Kein aspect_ratio gesetzt?

Mit image: Seitenverhältnis entspricht Quellbild. Ohne: Standard ist 16:9.

Kosten für 10 Sek. 720p-Video?

0,002 $ (Bild) + 0,70 $ (Ausgabe) = 0,702 $.

Ratenlimits?

60 Anfragen/Minute, 1 Anfrage/Sekunde. POST und GET zusammen zählen.

Videos >15 Sekunden?

Mit POST /v1/videos/extensions in mehreren Schritten verlängern; jeder Schritt asynchron.

Bird SMS API Kosten 2026: Preise und Übersicht

Emre Demir — Fri, 03 Apr 2026 07:12:13 +0000

TL;DR

Die Bird SMS API startet bei 0,00331 $ pro ausgehender US-Nachricht und 0,003 $ pro eingehender US-Nachricht. Damit gehört Bird zu den günstigsten SMS-API-Anbietern am Markt. Ein kostenloser Plan mit 5 SMS/Tag ist für Tests verfügbar. Der Pro-Plan für 49 $/Monat beinhaltet 1.000 SMS-Guthaben.

Teste Apidog noch heute

Einführung

MessageBird wurde 2023 zu Bird. Mit dem Rebranding kam ein Fokus auf KI-gestützte Omnichannel-Kommunikation: SMS, WhatsApp, E-Mail und Sprache unter einer Plattform. Auch das Preismodell wurde auf transparente Pay-as-you-go-Tarife umgestellt, die SMS-Basiskosten unterhalb von Twilio, Vonage und anderen großen Anbietern ermöglichen.

💡 Tipp: Für SMS-Integrationen brauchst du exakte Preisdaten und einfache API-Testmöglichkeiten. Apidog ermöglicht dir, Bird API-Requests zu designen, Testszenarien auszuführen und Antworten zu validieren – ohne zusätzliche Codezeile. Teste Apidog kostenlos und beschleunige deine Bird SMS-Integration.

Dieser Artikel gibt dir eine detaillierte Übersicht zu den Bird SMS-Kosten (2025/2026), zeigt Kostenfallen auf und vergleicht Bird mit Alternativen.

Bird SMS Preisübersicht

Bird nutzt eine zweiteilige Preisstruktur für SMS:

Plattform-Plan-Gebühr (monatliches Abonnement)
Gebühr pro Nachricht (Pay-as-you-go, zusätzlich zum Plan)

Pläne im Überblick:

Plan	Monatliche Kosten	Inklusive SMS
Kostenlos	0 $	5 SMS/Tag
Pro	49 $	1.000 SMS/Monat
Enterprise	Angepasst	Angepasstes Volumen

Nach Verbrauch des Inklusivkontingents zahlst du pro SMS:

Ausgehende SMS (USA): 0,00331 $/Nachricht
Eingehende SMS (USA): 0,003 $/Nachricht

Beachte, dass CRM-/Marketing-Tarife in EUR erscheinen, die genannten USD-Preise gelten für die Entwickler-API. Prüfe aktuelle Preise unter bird.com/en/pricing/sms.

Preisaufschlüsselung: SMS, MMS, WhatsApp und E-Mail

SMS

Ausgehende US-SMS: 0,00331 $/Nachricht. Die Tarife variieren international stark:

Land	Ausgehender Tarif (ca.)
Vereinigte Staaten	~0,00331 $
Vereinigtes Königreich	~0,036 €
Australien	~0,009 €
Deutschland	~0,056 €
Indien	variiert je nach Route
Brasilien	~0,047 €

Hinweis: Für US/Kanada fallen zusätzlich zu den Basistarifen 10DLC- und gebührenfreie Carrier-Gebühren an. Siehe Abschnitt "Versteckte Kosten".

MMS

MMS (Bildnachrichten) sind teurer. Bird unterstützt MMS für US- und kanadische Nummern. Die Kosten liegen ca. beim 3- bis 5-fachen einer SMS. Aktuelle MMS-Tarife findest du unter bird.com/en/pricing/sms.

Bird berechnet für WhatsApp:

Bearbeitungsgebühr (pro 1.000 Nachrichten):

| Volumen | Gebühr pro 1.000 Nachrichten |
|-------------------|-----------------------------|
| 1–1.000 | 0,001 $ |
| 1.001–100.000 | 0,005 $ |
| 100.001–500.000 | 0,0045 $ |
| 500.001+ | 0,004 $ |

Meta Durchleitungsgebühr (konversationsabhängig, variiert):

Marketing-Konversationen: 0,0250 $ (USA)
Utility-Konversationen: 0,0034 $ (USA)
Authentifizierung: 0,0034 $ (USA)

Bird gibt die Meta-Gebühren ohne Aufschlag weiter.

E-Mail

E-Mail via Bird API: ab 0,001 $/Mail bei niedrigen Volumen, mit sinkenden Preisen bei höherem Volumen. Pro-Plan enthält 10.000 E-Mails/Monat.

Sprache

Bird Voice API ist nutzungsbasiert. Ausgehende US-Anrufe: ca. 0,013–0,015 $/Minute. Eingehende Anrufe sind günstiger. Für Großkunden empfiehlt sich ein Gespräch mit dem Vertrieb.

Was Ihre Bird-Rechnung beeinflusst

Mehrere Faktoren können die Gesamtkosten erhöhen:

1. Land und Carrier-Routing

US-SMS sind günstig (0,00331 $), aber Nachrichten nach Deutschland (~0,056 €), Bangladesch (~0,208 €) oder Burundi (~0,269 €) sind deutlich teurer. Prüfe stets das länderspezifische Preisblatt.

2. Nummerntyp

Der gewählte Nummerntyp beeinflusst die Kosten:

Long Codes (10DLC): Standard-US-Nummern, erfordern Registrierung über The Campaign Registry (TCR).
Short Codes: 5–6-stellig, hoher Durchsatz, hohe Mietkosten (500–1.000 $/Monat).
Gebührenfreie Nummern: Mittlere Kosten, moderater Durchsatz.

Nummerngebühren kommen zu den SMS-Tarifen hinzu.

3. Nachrichtenlänge und Kodierung

Standard-SMS: 160 Zeichen (GSM-7). Überschreitest du das Limit, wird aufgeteilt und jede Nachricht einzeln abgerechnet. Unicode (z.B. Emojis) reduziert das Limit auf 70 Zeichen pro Segment.

4. Kanalmix

Bird bietet Workflows mit Fallback auf andere Kanäle (z.B. WhatsApp, E-Mail). Jede Weiterleitung kann zusätzliche Gebühren verursachen. Modellieren die deinen Kanalmix vorab.

5. Volumen

Bird veröffentlicht keine öffentlichen Volumenrabatte. Der Enterprise-Plan bietet individuelle Konditionen ab hohen Volumina (Millionen/Monat).

Versteckte Kosten und Gebühren

Trotz transparenter Preisdarstellung gibt es Posten, die überraschen können:

US-Carrier-Gebühren (10DLC)

Für US-Long Codes fallen folgende Gebühren an:

Markenregistrierung: Einmalig (ca. 4–44 $)
Kampagnenregistrierung: Monatlich (~10 $/Kampagne)
Carrier-Zuschlag pro Nachricht: z.T. mehrere Cent zusätzlich

Diese Gebühren werden 1:1 weitergegeben.

Telefonnummernmiete

US-Long Codes: 1–2 $/Monat
Gebührenfrei: 2–3 $/Monat
Short Codes: 500–1.000 $/Monat

Eingehende Webhooks und Verarbeitung

Eingehende SMS (z.B. Opt-out, Hilfe): 0,003 $/Nachricht (USA). Diese Kosten können sich bei automatisierten Flows summieren.

Plattform-Abonnement

Der Pro-Plan (49 $/Monat) ist fixer Overhead. Für kleine Volumen lohnt sich der kostenlose Tarif, für große Volumen zählt der Nachrichtentarif.

Wie Bird im Vergleich zu Alternativen abschneidet

Anbieter	Ausgehende US-SMS	Eingehende US-SMS	Hinweise
Bird	0,00331 $	0,003 $	Günstigster Basistarif, Omnichannel
Twilio	0,0079 $	0,0079 $	Höherer Tarif, großes Ökosystem
Telnyx	~0,004 $	~0,001 $	Wettbewerbsfähig, Carrier-Direktmodell
Plivo	0,0055 $	0,0005 $	Einfache Plattform, günstige Eingänge

Bird ist beim US-SMS-Basistarif führend. Twilio ist teurer, bietet aber Volumenrabatte. Telnyx/Plivo sind Alternativen mit einfachen Preisstrukturen. Bird eignet sich vor allem, wenn du mehrere Kanäle (WhatsApp, E-Mail) zentral steuern möchtest.

So startest du mit Bird

Konto erstellen: Registriere dich kostenfrei auf bird.com. 5 SMS/Tag sind ohne Kreditkarte testbar.
Marke & Kampagne registrieren: US 10DLC-Konformität via Dashboard (1–3 Werktage Bearbeitungszeit).
Telefonnummer besorgen: US-Long-Code-Nummer via Numbers API oder Dashboard anlegen.
Ersten API-Aufruf ausführen: Bird nutzt eine REST-API mit JSON. Beispiel:

curl -X POST https://api.bird.com/messages \
  -H "Authorization: AccessKey <dein_access_key>" \
  -H "Content-Type: application/json" \
  -d '{
    "originator": "+1234567890",
    "recipients": ["+1098765432"],
    "body": "Testnachricht von Bird API"
  }'

Weitere Infos: docs.bird.com – inkl. SDKs für Node.js, Python, PHP, Go, Java, Ruby und Webhook-Setup.

Fazit

Die Bird SMS API bietet mit 0,00331 $/ausgehender US-Nachricht einen der niedrigsten Einstiegspreise. Der kostenlose Plan eignet sich zum risikolosen Testen. Der Pro-Plan (49 $/Monat) ist für Teams mit 1.000 SMS/Monat ausgelegt.

Beachte zusätzliche Kosten: US 10DLC Carrier-Gebühren, Mietgebühren für Telefonnummern und internationale Tarife. Kalkuliere diese frühzeitig ein.

Nutze Apidog, um deine Bird-Integration End-to-End zu testen – inklusive Anfragenerstellung, Umgebungsvariablen, Testketten und Delivery Checks.

FAQ

Wie hoch ist der Preis pro Nachricht der Bird SMS API in den USA?

0,00331 $ pro ausgehender US-SMS, 0,003 $ pro eingehender US-SMS (API-Basistarife). Zusätzlich fallen Carrier-Gebühren (10DLC) an.

Ist Bird dasselbe wie MessageBird?

Ja, MessageBird wurde 2023 zu Bird. Das Unternehmen wurde 2011 gegründet, betreut u.a. Heineken, Booking.com, Uber und eBay. Einige Dokumentationen referenzieren noch MessageBird.

Berechnet Bird Gebühren für eingehende SMS?

Ja, 0,003 $/eingehender US-Nachricht. Auch Opt-out- und Hilfe-Antworten zählen.

Was ist der kostenlose Bird-Plan?

5 SMS/Tag, 10 E-Mails/Tag und 15 KI-Agent-Nachrichten/Tag inklusive, API-Zugang ohne Kreditkarte. Ideal zum Testen.

Wie vergleicht sich die Bird SMS-Preisgestaltung mit Twilio?

Bird (0,00331 $/SMS) ist günstiger als Twilio (0,0079 $/SMS). 100.000 SMS kosten bei Bird ca. 331 $, bei Twilio 790 $. Twilio bietet Volumenrabatte.

Gibt es versteckte Gebühren bei Bird SMS?

Ja, z.B. 10DLC-Markenregistrierung, Kampagnengebühren (~10 $/Monat), Carrier-Zuschläge und Telefonnummernmieten (1–2 $/Monat für Long Codes). Internationale SMS sind deutlich teurer.

Wie teste ich die Bird SMS API, ohne echte Nachrichten zu senden?

Nutze Apidogs Smart Mock-Funktion, um API-Antworten zu simulieren. Alternativ: Sandbox-Tools von Bird für Testnachrichten an eigene Nummer. Apidog erlaubt Testszenarien und Prüfungen ohne Produktivsystem.

Weiterführende Links:

Twilio SMS API Kosten: Vollständige Preisübersicht für 2026

Emre Demir — Fri, 03 Apr 2026 04:00:42 +0000

TL;DR

US Long-Code SMS (ausgehend und eingehend): $0.0083 pro Nachricht
MMS ausgehend: $0.022 pro Nachricht; MMS eingehend: $0.0165 pro Nachricht
Gebührenfreie SMS: $0.0083 pro Nachricht zuzüglich Anbieteraufschläge
Miete für Short Code: $1.000/Monat für einen zufälligen Code; $1.500/Monat für einen Wunsch-Code
10DLC Markenregistrierung: $4.50 einmalige Gebühr (aktualisiert August 2025); Kampagnen von $1.50 bis $10/Monat
Telefonnummer (Long Code): $1.15/Monat; gebührenfrei: $2.15/Monat
Anbietergebühren fallen zusätzlich zu allen Grundpreisen an
Mengenrabatte treten automatisch ab 150.000 Nachrichten pro Monat in Kraft
Kostenlose Testphase verfügbar; keine Kreditkarte zum Start erforderlich

Einleitung

Twilio ist die Standard-SMS-API für die meisten Entwicklerteams. Die Dokumentation ist gründlich, die Verfügbarkeit zuverlässig und die REST-API gut gestaltet. Doch sobald Sie von einem Nebenprojekt zu einer Produktions-App wechseln, wächst die Rechnung schnell. Sie zahlen nicht einen Preis pro Nachricht. Sie zahlen Twilios Grundgebühr, eine Anbietergebühr, eine Telefonnummerngebühr und möglicherweise zusätzlich 10DLC-Registrierungskosten.

Teste Apidog noch heute

💡 Tipp: Bevor Sie Ihre SMS-Integration entwickeln, testen Sie sie ordnungsgemäß. Apidog ermöglicht es Ihnen, automatisierte Testszenarien zu erstellen, die Ihre Twilio-Webhook-Antworten anhand Ihrer OpenAPI-Spezifikation validieren. Sie können Statuscodes bestätigen, Antwort-Body-Schemas überprüfen und Vertragstests in CI/CD ausführen. Testen Sie Apidog kostenlos, um Ihre SMS-Workflows zu validieren, bevor sie in Produktion gehen.

Dieser Artikel schlüsselt jeden Posten in der Preisgestaltung von Twilio auf. Sie erfahren, was Ihre Rechnung beeinflusst, was leicht übersehen wird und wie sich Twilio im Vergleich zu Alternativen schlägt.

Übersicht der Twilio SMS-Preisgestaltung

Twilio verwendet Pay-as-you-go-Preise. Sie zahlen pro Nachrichtensegment, pro Telefonnummer pro Monat und für alle optionalen Funktionen oder Registrierungen. Es gibt keine Verträge oder Mindestausgaben, es sei denn, Sie verhandeln einen Rabatt für feste Abnahmen bei Enterprise-Volumen.

Der Grundtarif für US-SMS auf einem Long Code beträgt $0.0083 pro Nachrichtensegment sowohl für eingehende als auch für ausgehende Nachrichten. Anbietergebühren, Nummernmiete und Compliance-Registrierung kommen jeden Monat zu diesem Grundtarif hinzu.

Twilio bietet automatische Mengenrabatte an, die ab 150.000 Nachrichten pro Monat und Nummerntyp automatisch greifen.

Preisübersicht: SMS, MMS, gebührenfreie Nummern und Short Codes

Long Code SMS (10-stellige Nummern)

Long Codes sind die standardmäßigen 10-stelligen Nummern für die meisten A2P (Application-to-Person) Nachrichten in den USA.

Nachrichtentyp	Preis pro Segment
SMS ausgehend	$0.0083
SMS eingehend	$0.0083
MMS ausgehend	$0.022
MMS eingehend	$0.0165

Praxis-Tipp: Twilio berechnet pro Nachrichtensegment, nicht pro Nachricht. Ein SMS-Segment umfasst 160 Zeichen (GSM-7). Bei Unicode (z. B. Emojis) sind es 70 Zeichen pro Segment. Beispiel: Eine Nachricht mit 200 Zeichen (ohne Unicode) kostet 2 Segmente.

Gebührenfreie Nummern

Gebührenfreie Nummern nutzen dieselben SMS-Basistarife wie Long Codes: $0.0083 pro Segment für SMS, $0.022 für ausgehende MMS, $0.02 für eingehende MMS.

Vorteil: Keine 10DLC-Registrierung notwendig, aber Verifizierung ist für vollen Durchsatz empfohlen.

Short Codes (5-6-stellige Nummern)

Short Codes sind für Kampagnen mit hohem Durchsatz gedacht. SMS-Preis pro Segment bleibt $0.0083, aber die Nummernmiete ist deutlich höher.

Short Code Typ	Monatliche Kosten
Zufälliger Short Code	$1.000/Monat (vierteljährlich)
Wunsch-Short Code	$1.500/Monat (vierteljährlich)
Eigenen Wunsch-Code mitbringen	$500/Monat (vierteljährlich)

Für MMS auf Short Codes fällt eine Einrichtungsgebühr von $500 an.

Mengenrabatte

Twilio staffelt die Preise bei wachsendem Volumen (pro Nummerntyp):

Monatliche Nachrichten	Preis pro Segment
1 bis 150.000	$0.0083
150.001 bis 300.000	$0.0081
300.001 bis 500.000	$0.0079
500.001 bis 750.000	$0.0077
750.001 bis 1.000.000	$0.0075
1.000.001+	$0.0073

Hinweis: Volumen werden pro Nummerntyp berechnet. Kombination von Long Code und gebührenfrei zählt nicht gemeinsam für Rabatte.

Was Ihre Twilio-Rechnung beeinflusst

Telefonnummerntyp

Die gewählte Nummer (Long Code, gebührenfrei, Short Code) bestimmt, welche Preistabelle gilt. Aufteilung des Traffics auf verschiedene Nummerntypen kann das Erreichen von Rabattstufen erschweren.

Nachrichtensegmente

Lange Nachrichten oder Unicode erhöhen die Segmentanzahl und somit die Kosten. Prüfen Sie Ihre Nachrichtentexte auf Segmentlänge mit Tools wie Twilio's Segment Calculator.

Anbietergebühren

Zusätzlich zum Grundpreis erhebt jeder große US-Anbieter einen eigenen Aufschlag pro Nachricht.

Anbieter	Gebühr ausgehend
AT&T	$0.0035
T-Mobile	$0.0045
Verizon	$0.004
US Cellular	$0.005
Andere	$0.004

Für MMS sind die Gebühren höher (AT&T: $0.009, T-Mobile: $0.01). Beispiel: Ausgehende SMS an AT&T = $0.0083 + $0.0035 = $0.0118 pro Segment.

Zielland

Internationale Preise variieren stark. Beispiel: UK $0.04, Indien $0.0029, Brasilien $0.075 pro SMS. Prüfen Sie die Twilio Preis-CSV.

10DLC-Registrierung

Für US-Long Codes im A2P-Bereich ist die Registrierung von Marke und Kampagne Pflicht. Nicht registrierter Traffic wird gefiltert.

Versteckte Kosten und Gebühren

10DLC-Registrierungsgebühren

Seit August 2025 gelten neue Gebühren:

Markenregistrierung:
- Einzelunternehmer/Kleinvolumen: $4.50 einmalig
- Standard: $46 einmalig
Kampagnenregistrierung:
- Überprüfung: $15 einmalig pro Kampagne
- Monatliche Gebühr: $1.50 bis $10 je nach Typ

Kampagnentyp	Monatliche Gebühr
Einzelunternehmer	$2
Geringes Volumen gemischt	$1.50
Standard	$10
Wohltätigkeitsorganisation/501(c)(3)	$3
Notdienste	$5

Standard-Überprüfung: $41.50. Einsprüche: $11. Erneute Authentifizierung: $12.50 pro Versuch.

Telefonnummerngebühren

Monatliche Miete: Long Codes $1.15, gebührenfrei $2.15. Viele Nummern für A/B-Tests oder lokale Präsenz erhöhen die Fixkosten.

Gebühr für fehlgeschlagene Nachrichten

$0.001 pro fehlgeschlagener Nachricht (Status "failed") – beachten bei Debugging und Anbieter-Filtering.

Optionale Funktions-Add-ons

Engagement Suite (Linkverkürzung, Klick-Tracking): $0.015/Nachricht nach 1.000 kostenlosen pro Monat
Compliance Toolkit: $0.015/Nachricht

Support-Pläne

Kostenloser Support ist limitiert. Kostenpflichtige Pläne starten bei $250/Monat ("Developer"). Für produktive Anwendungen ist oft ein Vertrag notwendig.

Wie Twilio im Vergleich zu Alternativen abschneidet

Anbieter	US SMS ausgehend	US SMS eingehend	Telefonnummer	10DLC erforderlich
Twilio	$0.0083 + Anbietergebühren	$0.0083 + Anbietergebühren	$1.15/Monat	Ja
Plivo	$0.005	$0.00035	$0.80/Monat	Ja
Telnyx	$0.004	$0.004	$1.00/Monat	Ja
Bird	~$0.007	~$0.007	Variiert	Ja

Praxis: Plivo und Telnyx sind günstiger. Twilio punktet bei DX, Dokumentation und Features wie Messaging Services, ist aber teurer. Für reines Volumen zu niedrigen Kosten sind Alternativen oft besser.

Wie man Twilio kostenlos testet

Twilio bietet ein kostenloses Testkonto ohne Kreditkarte. Sie erhalten ein Testguthaben und können:

Eine Test-Telefonnummer bereitstellen
SMS über die API senden und empfangen
Webhook-Zustellung testen
Twilio-Konsole und Logs ausprobieren

Testnachrichten an nicht verifizierte Nummern enthalten das Präfix "Sent from your Twilio trial account". Für produktiven Einsatz ist ein Upgrade nötig.

Keine monatlichen Mindestausgaben im Pay-as-you-go-Tarif.

So testen Sie Ihre Twilio SMS-Integration mit Apidog

Nach dem Einrichten Ihrer Twilio-Zugangsdaten und Webhooks sollten Sie Ihre Integration automatisiert testen. Manuelles Testen deckt keine Edge-Cases und keine Schemafehler ab.

Mit Apidog Testszenarien können Sie:

Ihre Twilio-Webhook-Spezifikation direkt importieren
Schritte für jeden Nachrichtenfluss anlegen: SMS senden, Callback empfangen, Antwort verarbeiten
Den Orchestrierungsmodus nutzen, um Abläufe zu steuern
Daten zwischen Schritten mit {{$.stepId.response.body.field}} weitergeben (z. B. Nachrichten-SID)

Beispiel für ein automatisiertes Testszenario:

steps:
  - name: SMS senden
    request:
      method: POST
      url: https://api.twilio.com/2010-04-01/Accounts/{AccountSid}/Messages.json
      body:
        To: "+49123456789"
        From: "+49111222333"
        Body: "Testnachricht"
    extract:
      messageSid: $.response.body.sid
  - name: Webhook-Callback empfangen
    request:
      method: POST
      url: https://your-app.com/sms-webhook
      body:
        MessageSid: "{{$.SMS senden.messageSid}}"

Vertragstests:

Definieren Sie Ihr erwartetes Webhook-Payload-Schema in Ihrer OpenAPI-Spezifikation. Apidog prüft dann:

Statuscode wie dokumentiert
Alle Pflichtfelder vorhanden
Feldtypen stimmen
Keine unerwarteten Felder (sofern nicht explizit erlaubt)

So erhalten Sie vollständige Testabdeckung ohne eigene Assertion-Skripte.

Schnellstart:

Laden Sie Apidog kostenlos herunter
Importieren Sie Ihre Twilio-API-Spezifikation oder definieren Sie das Webhook-Schema
Erstellen Sie Testszenarien für SMS-Versand und -Empfang

Fazit

Twilio SMS startet ab $0.0083 pro Segment, aber tatsächliche Kosten beinhalten Anbietergebühren, Nummernmiete und ggf. 10DLC-Registrierung. Eine ausgehende AT&T-SMS kostet realistisch $0.0118 pro Segment. Für Standard-10DLC-Kampagnen kommen $10/Monat pro Kampagne dazu.

Preise sind transparent, Rabatte automatisch, aber Sie müssen alle Einzelposten berücksichtigen.

Empfehlung:

Modellieren Sie Ihre Kosten, bauen Sie Ihre Integration, und testen Sie sie gründlich. Mit Apidogs Testszenarien und Vertragstests validieren Sie Twilio-Workflows automatisiert und ohne Custom-Testcode.

FAQ

F: Was ist der Grundpreis für eine ausgehende US-SMS über Twilio?

A: $0.0083 pro Segment (Long Code). Anbieteraufschläge kommen hinzu. AT&T z. B. +$0.0035 = $0.0118/Segment.

F: Berechnet Twilio Gebühren für eingehende SMS?

A: Ja, $0.0083/Segment auf Long Code und gebührenfreien Nummern. Anbietergebühren können ebenfalls anfallen.

F: Was ist 10DLC und muss ich dafür bezahlen?

A: 10DLC ist das US-Registrierungssystem für A2P-SMS via Long Code. Registrierung ist Pflicht: Marke $4.50 einmalig, Kampagne $1.50–$10/Monat.

F: Wie viel kostet ein Twilio Short Code?

A: Zufällig: $1.000/Monat, Wunsch: $1.500/Monat (jeweils vierteljährlich abgerechnet). MMS-Aktivierung: $500 einmalig.

F: Bietet Twilio Mengenrabatte an?

A: Ja. Ab 150.001 Nachrichten/Monat und Nummerntyp sinken die Preise stufenweise auf bis zu $0.0073/Segment.

F: Gibt es eine kostenlose Testphase für Twilio?

A: Ja. Kostenloses Testkonto, kein Kreditkarte nötig, echtes Messaging möglich (mit Testpräfix).

F: Was ist die günstigste Twilio-Alternative für SMS?

A: Plivo ($0.005/ausgehend, $0.00035/eingehend) und Telnyx ($0.004 pro Nachricht) sind günstiger, erfordern aber ebenfalls 10DLC. Twilio bietet dafür mehr Features und besseren Support für komplexe Fälle.

Vonage SMS API Kosten: Preise 2026

Emre Demir — Fri, 03 Apr 2026 03:53:48 +0000

TL;DR

Die Preise für die Vonage SMS API starten in den USA bei $0.00809 pro ausgehender Nachricht und $0.00649 pro eingehender Nachricht. Es gibt keine monatlichen Mindestgebühren – Sie zahlen nur, was Sie tatsächlich senden oder empfangen. Internationale Preise variieren stark, in manchen Ländern kostet eine SMS mehr als $1.00. Zur Entwicklung und zum Testen einer Vonage SMS-Integration empfiehlt sich Apidog: Testanfragen versenden, Antworten validieren und Fehler aufdecken, bevor Ihr Code live geht.

Testen Sie Apidog noch heute

Einführung

Wenn Sie bereits mit Nexmo gearbeitet haben, sind Sie mit Vonage vertraut. Vonage übernahm 2016 Nexmo, die Entwicklerplattform für SMS- und Kommunikations-APIs. Noch immer bleibt developer.vonage.com (ehemals nexmo.com/developers) der zentrale Anlaufpunkt für technische Ressourcen. Seit der Übernahme durch Ericsson 2022 ist Vonage ein globaler Telekommunikationsanbieter mit Fokus auf das API-Geschäft.

Vonage zählt heute über 100.000 Unternehmenskunden und 1,6 Millionen registrierte Entwickler. Die Plattform bietet ein ausgereiftes Pay-as-you-go-Preismodell ohne Vertragsbindung und deckt über 190 Länder ab.

💡Bevor Sie Ihre Integration weiter vorantreiben, benötigen Sie ein gutes API-Testwerkzeug. Apidog ermöglicht es Ihnen, Testszenarien für Ihre Vonage SMS-Anfragen zu erstellen, Antworten anhand erwarteter Schemas zu validieren und mehrere API-Aufrufe in einem einzigen Workflow zu verketten. Probieren Sie Apidog kostenlos aus. Keine Kreditkarte erforderlich.

Übersicht der Vonage SMS-Preise

Vonage verwendet für die SMS API ein Pay-as-you-go-Modell. Es gibt keine Plattform- oder Grundgebühr. Sie zahlen pro Nachricht, wobei die Preise vom Zielland und Nummerntyp abhängen.

Kurzüberblick der US-Preise:

Nachrichtentyp	Preis pro Nachricht
Ausgehende SMS (US LVN)	$0.00809
Eingehende SMS (US LVN)	$0.00649
Ausgehende SMS (US Toll-Free)	Vertrieb kontaktieren
Eingehende SMS (US Toll-Free)	Kostenlos

LVN steht für Local Virtual Number (10DLC, die Standard-US-Langnummer). Die Preise werden pro Land festgelegt und in Echtzeit nach Nutzung abgerechnet.

Die vollständige globale Preisliste gibt es im Excel-Format auf Ihrem Nexmo/Vonage-Dashboard. Damit können Sie internationale Kampagnen exakt kalkulieren.

Preisaufschlüsselung: Ausgehend, Eingehend, MMS und WhatsApp

Ausgehende SMS

Ausgehende Nachrichten sind SMS, die Sie von Ihrer Anwendung an Endnutzer senden. US-Tarif: $0.00809 pro Nachricht (über lokale virtuelle Nummer). Preise können sich ändern – das Vonage-Dashboard ist die Referenz.

Eingehende SMS

Eingehende Nachrichten sind SMS, die auf einer von Ihnen gemieteten Nummer empfangen werden. In den USA: $0.00649 pro eingehender Nachricht. Gebührenfreie Nummern nehmen teils kostenlos SMS entgegen – prüfen Sie das in Ihrem Account.

MMS-Preise

Vonage unterstützt MMS über die Messages API, veröffentlicht aber keine festen Preise dafür. Für MMS-Preise müssen Sie den Vertrieb kontaktieren, da diese je nach Carrier und Land variieren.

WhatsApp über Vonage

WhatsApp-Nachrichten laufen über die Messages API. Es fallen zwei Gebühren an:

WhatsApp-Gebühr: Meta berechnet pro zugestellter Nachricht, abhängig von der Gesprächskategorie (Marketing, Utility, Authentifizierung, Service). WhatsApp-Preise hier.
Vonage-Plattformgebühr: Startet ab $0.00015 pro Nachricht, abhängig von Kategorie und Volumen.

Facebook Messenger

Unterstützt, abgerechnet mit $0.0011 pro zugestellter Nachricht über die Messages API.

RCS (Rich Communication Services)

Vonage unterstützt RCS-Nachrichten mit anbieterspezifischen US-Tarifen:

Anbieter	RCS Rich (textbasiert)	RCS Rich Media
T-Mobile	$0.00620	$0.01250
Verizon	$0.00400	$0.00600
AT&T	$0.00450	$0.01000
US Cellular	$0.00620	$0.01350

Zusätzlich fällt eine einmalige Einrichtungsgebühr von $600 pro Land für RCS an.

Was Ihre Vonage-Rechnung beeinflusst

Mehrere Faktoren bestimmen Ihre monatlichen Kosten:

Zielland

Der wichtigste Kostenfaktor. SMS in die USA kosten nur Bruchteile eines Cents, Nachrichten in Länder mit schlechter Netzabdeckung können 0,50 $ oder mehr kosten. Prüfen Sie stets die globale Preisliste vor der Kampagne.

Nummerntyp

In den USA gibt es:

Langnummer (10DLC): Standardnummer, günstig für P2P und App-to-Person.
Gebührenfreie Nummer: Höherer Durchsatz, eingehende SMS oft kostenlos.
Kurznummer: Für Marketing und hohes Volumen, Vorabgenehmigung und Registrierung nötig.

Jeder Typ hat eigene Preise und Mietkosten.

Mietgebühren für Nummern

Virtuelle Nummern kosten extra. US-Langnummern starten bei wenigen Dollar pro Monat, gebührenfreie Nummern und Kurznummern sind teurer. Mietkosten fallen zusätzlich zu den Nachrichtenkosten an.

Nachrichtenkodierung

Standard-SMS: 160 Zeichen (GSM-7). Unicode (z. B. Emojis) reduziert das Limit auf 70 Zeichen. Nachrichten, die das Limit überschreiten, werden in mehrere SMS aufgeteilt – das kann die Kosten schnell erhöhen.

Carrier-Zuschläge

US-Carrier berechnen eigene Zuschläge (vor allem für A2P-Nachrichten). Vonage reicht diese durch. Sie sind auf der Monatsabrechnung explizit aufgeführt.

Versteckte Kosten, auf die Sie achten sollten

Die pro-Nachricht-Preise sind transparent, aber es gibt Zusatzkosten:

Support-Stufen

Kostenlos: Community-Forum, Doku.
Business: Kostenpflichtig.
Premium (24/7, dedizierter Account Manager): $3.300/Monat.

Für kritische, kundennahe Workflows sollten Sie Support-Kosten einplanen.

Zusatz-APIs

Einige Vonage-APIs kosten monatlich:

Add-on	Monatliche Kosten
Audit API	$550/Monat
Auto-redact (PII-Entfernung)	$1.100/Monat
Reports API	$495/Monat (oder $0.00049/CDR Pay-as-you-go)

Audit API: Für hohe Compliance-Anforderungen.

Auto-redact: Entfernt automatisch PII aus Logs.

Kosten der Verify API

Für Zwei-Faktor-Authentifizierung: $0.0572 pro erfolgreicher Verifizierung (plus Gebühren für Nachrichten/Anrufversuche). Fehlversuche verursachen trotzdem SMS-Kosten.

Nummernregistrierung (US 10DLC)

Für A2P-SMS mit Langnummern in den USA ist die Registrierung bei The Campaign Registry (TCR) Pflicht. Kosten:

Markenregistrierung: einmalig
Kampagnenregistrierung: monatlich pro Kampagne

Fehlende Registrierung führt zu blockierten Nachrichten.

Vonage vs. Alternativen

US-Preise im Vergleich:

Anbieter	US ausgehende SMS	US eingehende SMS	Kostenlose Testversion	Support
Vonage	$0.00809	$0.00649	Ja (nur verifizierte Nummern)	Kostenpflichtige Stufen; $3.300/Monat für 24/7
Twilio	$0.0079	$0.0075	Ja ($15 Guthaben)	Kostenpflichtiger Support ab $250/Monat
Plivo	$0.0055	$0.0005	Ja	Kostenloser Basis; kostenpflichtige Stufen
Telnyx	$0.004	$0.002	Ja ($5 Guthaben)	24/7 E-Mail kostenlos; Telefon mit bezahlter Option

Zu beachten:

Telnyx am günstigsten für US-SMS, aber neuer und kleiner.
Plivo: Günstig für eingehende SMS, Entwickler-freundlich.
Twilio: Größtes Ökosystem, beste Doku, aber teurer.
Vonage: Preislich mittig, durch Ericsson starke Carrier-Beziehungen.

Neben dem Preis zählen: Zustellrate, Compliance, Qualität der Entwicklertools und Support.

So testen Sie Vonage kostenlos

Vonage bietet ein kostenloses Testkonto an.

Was Sie erhalten

Virtuelle Testnummer für SMS-Senden und -Empfangen
API-Schlüssel & Geheimnis
Volle Entwicklerdokumentation und SDKs
Testguthaben für begrenzte Anzahl Nachrichten

Was ist eingeschränkt

Im Testmodus können Sie nur an verifizierte Nummern senden. Upgrade auf ein kostenpflichtiges Konto ist erforderlich, um beliebige Nummern zu erreichen.

So beginnen Sie

Gehen Sie zu dashboard.nexmo.com oder vonage.com/communications-apis
Kostenlos registrieren
Telefonnummer bestätigen
API-Schlüssel und Geheimnis aus dem Dashboard holen
Ersten API-Aufruf per REST oder SDK absetzen

Vonage bietet Server-SDKs für Node.js, Python, PHP, Ruby, Java, .NET und Go. Alternativ nutzen Sie direkt die REST API mit jedem HTTP-Client.

So testen Sie Ihre Vonage SMS-Integration mit Apidog

Mit Ihren Vonage API-Credentials können Sie Ihre Integration vor dem Go-Live effizient testen. Apidog ist für diese Aufgabe optimiert.

Mit den „Test-Szenarien“ von Apidog lassen sich mehrere API-Aufrufe zu automatisierten Testflüssen verketten – genauso wie Ihr tatsächlicher Workflow: SMS senden, Status prüfen, Fehler abfangen.

Einrichten eines Testszenarios

Navigieren Sie in Apidog zum Modul Tests.
Erstellen Sie ein neues Testszenario.
Fügen Sie Schritte hinzu, z.B.:
- Import aus Ihrer API-Spezifikation (OpenAPI)
- Benutzerdefinierte Anfrage an Vonage-REST-API
- Import eines cURL-Befehls aus der Vonage-Doku

Beispiel:

Für einen SMS-Sende-Test nutzen Sie eine POST-Anfrage an

https://rest.nexmo.com/sms/json

mit API-Schlüssel, Geheimnis, Absender, Empfänger und Nachricht als Formularparameter.

Validierung der Antwort

Apidog prüft die Antwort gegen Ihr Schema. Für Vonage SMS API sollte die Response ein JSON-Objekt mit messages-Array enthalten. Erfolgreich ist:

HTTP-Statuscode ist 200
messages[0].status ist "0"
messages[0].message-id ist nicht leer

Fügen Sie Assertions in Apidog hinzu, um genau das zu prüfen. Fehlerhafte Statuscodes markieren den Testrot und zeigen die Antwort zum Debuggen an.

Datenübergabe zwischen Anfragen

Mit der Syntax {{$.stepId.response.body.field}} übergeben Sie Daten zwischen Schritten. Beispiel: message-id aus Schritt 1 automatisch in Schritt 2 (Statusabfrage) einfügen.

Ausführen von Tests in CI/CD

Binden Sie Apidog in Ihre CI/CD-Pipeline ein (GitHub Actions, GitLab CI, Jenkins):

Exportieren Sie Ihr Testszenario.
Führen Sie es mit Apidog CLI bei jedem Pull Request aus.
So erkennen Sie Integrations-Fehler, bevor sie in die Produktion gelangen.

Testen Sie es kostenlos unter apidog.com. Keine Kreditkarte erforderlich.

Fazit

Vonage SMS API ist Pay-as-you-go ohne Grundgebühr. US-SMS kosten $0.00809 (ausgehend) bzw. $0.00649 (eingehend). Die tatsächlichen Kosten hängen von Land, Nummerntyp und Nachrichtenkodierung ab. Premium-Features wie Audit API, Auto-redact und 24/7-Support verursachen zusätzliche monatliche Kosten.

Vergleichen Sie Alternativen: Telnyx und Plivo sind günstiger, Twilio hat das größte Ökosystem. Vonage punktet mit globaler Reichweite und Carrier-Grade-Infrastruktur (Ericsson).

Nutzen Sie Apidog, um Ihre Vonage-Integration vor dem Go-Live vollständig zu testen: Nachrichtenflüsse abbilden, Antworten prüfen, Fehler früh erkennen.

FAQ

Ist Vonage dasselbe wie Nexmo?

Ja. Vonage hat Nexmo 2016 übernommen. Die Entwicklerplattform läuft weiterhin über developer.vonage.com, ältere Integrationen nutzen noch rest.nexmo.com als Endpoint.

Verlangt Vonage eine monatliche Gebühr für SMS?

Nein. Sie zahlen pro Nachricht, plus eventuelle Mietgebühren für virtuelle Nummern. Zusatzfunktionen wie Audit API oder Auto-redact sind kostenpflichtige Add-ons.

Wie viel kostet eine Vonage Telefonnummer?

US-Langnummern starten bei wenigen Dollar pro Monat. Gebührenfreie Nummern und Kurznummern sind teurer. Prüfen Sie das Dashboard für aktuelle Preise in Ihrem Land.

Welche Länder unterstützt Vonage SMS?

Über 190 Länder. Preise variieren stark – einige Märkte kosten 0,50 $ oder mehr pro Nachricht. Die globale Preisliste finden Sie im Vonage-Dashboard.

Bietet Vonage Mengenrabatte?

Ja. Für hohes Volumen können Sie individuelle Konditionen verhandeln. Bis dahin gelten die Standardtarife.

Kann ich eingehende SMS kostenlos empfangen?

US-Gebührenfreie Nummern empfangen oft kostenlos SMS. Langnummern kosten $0.00649 pro eingehender Nachricht. Preise variieren je nach Land.

Wie schneidet Vonage im Vergleich zu Twilio für SMS ab?

Der US-Preis von Vonage ($0.00809) ist leicht höher als Twilio ($0.0079). Twilio bietet mehr Integrationen und ein größeres Entwicklernetzwerk. Vonage punktet mit Carrier-Level-Partnerschaften (Ericsson) und attraktiven internationalen Preisen. Für reine US-SMS ist der Preisunterschied minimal – Entwicklererfahrung und Support sind oft entscheidend.

Cursor 3: Auswirkungen für API-Entwickler

Emre Demir — Fri, 03 Apr 2026 03:49:36 +0000

Kurz gesagt: Cursor 3 wurde am 2. April 2026 veröffentlicht und ersetzt die IDE-zentrierte Benutzeroberfläche durch einen Agenten-zentrierten Arbeitsbereich. Für API-Entwickler sind die größten Neuerungen die parallele Ausführung von Agenten, umfangreichere MCP-Tool-Ausgaben und eine Übergabe von der Cloud zum lokalen System, die Ihre Workflows ohne Unterbrechung am Laufen hält. Wenn Sie Cursor 3 mit dem MCP-Server von Apidog koppeln, können Ihre KI-Agenten Ihre Live-API-Spezifikationen lesen und präzisen, schema-bewussten Code generieren, ohne jegliches Kopieren und Einfügen.

Teste Apidog noch heute

Die Veränderung, die Sie wahrscheinlich kommen sahen

KI-Code-Editoren werden stetig leistungsfähiger, aber Cursor 3 ist mehr als ein simples Update – es verändert grundlegend, wie eine KI-Entwicklungsumgebung aufgebaut ist.

Vor Cursor 3 arbeiteten Sie wie in einer klassischen IDE: Datei öffnen, Agenten um Hilfe bitten, Unterschiede prüfen, weiterarbeiten. Agenten waren lediglich Assistenten.

Jetzt stehen Agenten im Mittelpunkt. Sie verwalten mehrere Agenten parallel, ähnlich wie Tabs im Browser, und beobachten die jeweiligen Ausgaben. Das ist besonders für API-Entwickler relevant, deren Arbeit ohnehin parallel und koordiniert abläuft – Endpunkte schreiben, Verträge testen, Dokumentation aktualisieren und Schemafehler beheben passieren in jedem Projekt nebeneinander.

💡 Hinweis: Cursor 3 kennt Ihre API-Spezifikation nicht automatisch. Verbinden Sie deshalb den Apidog MCP Server. Einmal eingerichtet, können Ihre Cursor-Agenten OpenAPI-Schemas, Endpunktdefinitionen und Testszenarien direkt von Apidog abrufen. So stimmen Feldnamen, Strukturen und generierter Code mit Ihrer Spezifikation überein.

Dieser Artikel zeigt die wichtigsten Änderungen in Cursor 3, erklärt ihre Bedeutung für die API-Entwicklung und gibt eine konkrete Schritt-für-Schritt-Anleitung für den Workflow mit dem Apidog MCP Server.

Was ist neu in Cursor 3

Cursor 3 wurde am 2. April 2026 veröffentlicht. Das zentrale Feature ist das neue Agentenfenster, aber es gibt weitere, speziell für API-Entwickler relevante Änderungen.

Agentenfenster

Das Agentenfenster stellt Agenten in den Mittelpunkt. Sie können mehrere Agenten gleichzeitig über verschiedene Repositories hinweg ausführen – lokal, in Git-Worktrees, der Cursor-Cloud oder via SSH auf Remote-Systemen.

Zugriff: Cmd+Shift+P → Agents Window. Die klassische IDE bleibt verfügbar.

Praxisbeispiel: Während ein Agent einen neuen API-Endpunkt erstellt, behebt ein anderer einen Fehler in einer Bibliothek. Sie beobachten, vergleichen und übernehmen die besten Änderungen.

Designmodus

Im Agentenfenster ermöglicht der Designmodus das direkte Annotieren von Browser-UIs. Markieren Sie Elemente und fügen Sie sie dem Agentenkontext hinzu – ganz ohne lange Beschreibungen. Besonders praktisch beim Frontend-Test von APIs.

Shortcuts:

Cmd+Shift+D – Designmodus umschalten
Shift+Drag – Bereich auswählen
Cmd+L – Element zum Chat hinzufügen

MCP-Apps: Strukturierte Inhaltsausgabe

MCP-Apps liefern jetzt strukturierte Inhalte statt reinem Text. Besonders mit dem Apidog MCP Server profitieren Sie: Endpunktdefinitionen, Schemadaten und Testergebnisse kommen als sauber strukturierte Daten zum Agenten – kein Text-Parsing mehr.

Worktrees, /best-of-n und Isolation

/worktree: Erstellt einen isolierten Git-Worktree. Ideal für risikofreie Experimente und neue Module.
/best-of-n: Führt dieselbe Aufgabe parallel mit mehreren Modellen aus, jeweils in eigenem Worktree. Perfekt, wenn Sie unterschiedliche Implementierungen vergleichen wollen (z. B. Claude, GPT-4o, Gemini).

Cloud-zu-Lokal-Übergabe

Agenten können Aufgaben zwischen Cloud und lokalem System verschieben. Starten Sie eine Aufgabe in der Cloud, testen Sie sie lokal gegen echte Dienste oder lassen Sie sie in der Cloud weiterlaufen, wenn Ihr Laptop aus ist.

Was es für die API-Entwicklung bedeutet

API-Arbeit ist geprägt von häufigem Kontextwechsel zwischen Spezifikation, Client (Apidog), Code-Editor, Terminal und Dokumentation. Cursor 3 bringt hier praktische Verbesserungen – vor allem in Verbindung mit der MCP-Integration.

Parallele Endpunktentwicklung

Statt Endpunkte nacheinander zu bauen, können Sie jetzt für jeden Endpunkt einen Agenten parallel starten. Beschreiben Sie das Ziel, lassen Sie die Agenten arbeiten, prüfen Sie die Ausgaben und übernehmen Sie die besten Resultate. Das verkürzt die Zeit bis zu einem prüfbaren Entwurf erheblich.

Schema-bewusste Codegenerierung

Ohne Zugriff auf Ihre OpenAPI-Spezifikation rät ein Agent nur. Mit angebundener Apidog-MCP-Integration liest der Agent das echte Schema und generiert Code, der exakt Ihren Vorgaben entspricht (z. B. korrekte Felder für POST /orders). Das reduziert Korrekturaufwand.

Vertragstests im Editor

Agenten können Terminalbefehle ausführen. Kombiniert mit der Apidog CLI lassen sich Testszenarien direkt im Editor automatisiert validieren:

apidog run --scenario <test-id>

Der Agent sieht das Ergebnis, passt bei Fehlern den Code an und wiederholt den Test. Das ist eine enge Feedbackschleife zwischen Implementierung und Tests.

Dokumentation aktuell halten

Cursor-Agenten können die Apidog-Dokumentation via MCP lesen und prüfen, ob Code und Spezifikation übereinstimmen. Abweichungen werden angezeigt. Sie entscheiden, was angepasst wird – Dokumentationsdrift wird so zum festen Schritt im Workflow.

Was sich nicht geändert hat

Cursor 3 testet Ihre APIs nicht automatisch und ersetzt kein QA-Tool.
Für Authentifizierung, Ratenbegrenzung und Performance-Tests benötigen Sie weiterhin passende Werkzeuge.
Strukturierte MCP-Ausgaben erfordern, dass Ihr MCP-Server dies unterstützt (Apidog tut es bereits).

Cursor 3 + Apidog MCP Server: Ein spezifischer Workflow

Nutzen Sie die vollen Möglichkeiten von Cursor 3 und Apidog MCP Server mit folgendem Workflow.

Die Einrichtung

Fügen Sie den Apidog MCP Server in den Cursor-Einstellungen hinzu. Beispielkonfiguration:

{
  "mcpServers": {
    "apidog": {
      "command": "npx",
      "args": ["-y", "@apidog/mcp-server@latest"],
      "env": {
        "APIDOG_ACCESS_TOKEN": "your_access_token"
      }
    }
  }
}

Ihr Zugriffstoken finden Sie in Apidog unter Konto-Einstellungen > API-Zugriffstoken. Nach der Verbindung stehen Ihnen Tools wie get_endpoint_detail, list_endpoints, get_schema im Live-Projekt zur Verfügung.

Workflow: Einen neuen Endpunkt aus der Spezifikation erstellen

Sie haben z. B. einen neuen Endpunkt POST /invoices zur Apidog-Spezifikation hinzugefügt – inkl. Anforderungs- und Antwortschema sowie Testszenario.

Vorgehen im Agentenfenster:

"Suchen Sie den POST /invoices Endpunkt im Apidog-Projekt. Lesen Sie seine Anfrage- und Antwortschemata. Generieren Sie einen Node.js/Express-Handler, der der Spezifikation entspricht. Führen Sie dann das Testszenario aus, um es zu überprüfen."

Der Agent:

Ruft per MCP die Spezifikation ab (get_endpoint_detail)
Generiert Code anhand der echten Schemadefinition
Führt apidog run --scenario invoice-creation-test --env staging im Terminal aus
Korrigiert den Handler bei fehlgeschlagenen Tests

Sie überprüfen und übernehmen die Änderungen.

/best-of-n für komplexe Endpunkte

Bei komplexer Logik nutzen Sie /best-of-n, um mehrere Agenten unabhängig Implementierungen generieren zu lassen. Jeder Agent nutzt die gleiche Spezifikation. Anschließend vergleichen Sie die Lösungen im Worktree und wählen die beste aus.

Dokumentation synchronisieren

Nach Deployment können Sie mit einem weiteren Agentenlauf prüfen:

"Überprüfen Sie die Apidog-Dokumentation für POST /invoices. Vergleichen Sie sie mit dem Code in invoices.js. Kennzeichnen Sie alle Diskrepanzen. Wenn die Antwortstruktur im Code von der Spezifikation abweicht, aktualisieren Sie die Apidog-Spezifikation entsprechend."

Der Agent liest beide Quellen, schlägt ggf. Anpassungen an Spezifikation oder Code vor, und Sie entscheiden.

Mehr zur MCP-Server-Integration: [Apidog MCP Server Übersicht]

Automatisierte Testausführungen: [Apidog CLI Erste Schritte]

Praktische Einrichtung: Erste Schritte

So setzen Sie Cursor 3 mit dem Apidog MCP Server in der Praxis auf:

Schritt 1: Cursor aktualisieren

Laden Sie die aktuelle Version von cursor.com herunter. Nach der Installation öffnen Sie per Cmd+Shift+P die Befehlspalette und wählen „Agents Window“, um Cursor 3 zu bestätigen.

Schritt 2: Apidog-Zugriffstoken generieren

Melden Sie sich bei Apidog an, gehen Sie zu Konto-Einstellungen > API-Zugriffstoken, erzeugen Sie ein neues Token und kopieren Sie es.

Schritt 3: Apidog MCP Server zu Cursor hinzufügen

Öffnen Sie die Cursor-Einstellungen > MCP und fügen Sie die Serverkonfiguration ein:

{
  "mcpServers": {
    "apidog": {
      "command": "npx",
      "args": ["-y", "@apidog/mcp-server@latest"],
      "env": {
        "APIDOG_ACCESS_TOKEN": "your_token_here",
        "APIDOG_PROJECT_ID": "your_project_id"
      }
    }
  }
}

Die Projekt-ID finden Sie in der Apidog-URL, wenn Sie das Projekt öffnen. Speichern und Cursor neu starten.

Schritt 4: Verbindung überprüfen

Öffnen Sie das Agentenfenster, starten Sie eine neue Sitzung und geben Sie ein:

„Listen Sie die Endpunkte in meinem Apidog-Projekt auf.“

Wenn eine Liste der Endpunkte erscheint, funktioniert die Integration.

Schritt 5: Apidog CLI installieren und konfigurieren

Installieren Sie die CLI global:

npm install -g apidog-cli

Mit apidog -v prüfen Sie die Version. Im CI/CD-Tab eines Apidog-Testszenarios finden Sie den passenden CLI-Befehl mit Ihren Zugangsdaten und der Szenario-ID. Führen Sie diesen Befehl im Cursor-Terminal aus oder lassen Sie einen Agenten das übernehmen.

Schritt 6: Erste MCP-gesteuerte Agentenaufgabe ausführen

Beschreiben Sie im Agentenfenster eine task-bezogene Anweisung, z. B.:
„Suchen Sie das Schema für das Benutzerobjekt in Apidog. Generieren Sie eine TypeScript-Schnittstelle, die genau dazu passt.“

Vergleichen Sie die Ausgabe mit der tatsächlichen Spezifikation, um die Integration zu prüfen.

Von hier aus können Sie Workflows für Spezifikationszugriff, Codegenerierung und Testausführung kombinieren.

Zusammenfassung

Cursor 3 verändert die Arbeitsweise mit KI in Entwicklungsumgebungen grundlegend. Die Umstellung auf ein Agenten-zentriertes Paradigma entspricht modernen API-Workflows, in denen Sie mehrere Endpunkte und Umgebungen orchestrieren statt einzelne Funktionen zu schreiben.

Die strukturierte MCP-Ausgabe ist ein unterschätztes, aber zentrales Feature für API-Entwickler: Agenten erhalten typisierte Daten und generieren damit Code, der direkt zur Spezifikation passt – mit weniger Nachbesserungen.

In Kombination mit dem Apidog MCP Server und der CLI entsteht ein Workflow, bei dem der KI-Agent Ihre API wirklich kennt: Er liest die Spezifikation, generiert passenden Code und validiert die Implementierung direkt per Testszenario. Das ist keine Demo, sondern ein produktiver Loop für Ihre tägliche API-Arbeit.

Häufig gestellte Fragen

Ersetzt Cursor 3 die bestehende IDE-Oberfläche?

Nein. Cursor 3 ergänzt die IDE um das Agentenfenster. Sie können beide parallel oder abwechselnd nutzen.

Was ist der Unterschied zwischen Cursor 3 und der vorherigen Version von Cursor?

Der Hauptunterschied ist das Architektur-Paradigma: Cursor 3 setzt Agenten in den Fokus (mit paralleler Ausführung, Cloud-zu-Lokal-Übergabe, Designmodus, /worktree und /best-of-n). Der Editor bleibt verfügbar.

Wie verbindet sich der Apidog MCP Server mit Cursor 3?

Fügen Sie den Apidog MCP Server als MCP-Konfiguration in den Cursor-Einstellungen hinzu. Der Server stellt API-Daten Ihres Apidog-Projekts als aufrufbare Tools bereit. Agenten lesen so Endpunktspezifikationen, Schemata und Testszenarien direkt und strukturiert, nicht nur als Text.

Können Cursor 3 Agenten Apidog Testszenarien automatisch ausführen?

Ja, über die Apidog CLI. Agenten können Terminalbefehle im Workflow nutzen, Testszenarien ausführen, die Ergebnisse lesen und ihren Code daraufhin anpassen. Das ermöglicht eine schnelle Feedbackschleife zwischen Code und API-Tests.

Benötige ich einen kostenpflichtigen Cursor-Plan, um das Agentenfenster zu nutzen?

Das Agentenfenster ist in allen Plänen verfügbar. Die Cloud-Agenten-Ausführung erfordert allerdings ein kostenpflichtiges Abonnement; lokale Agenten laufen auch im Free-Plan. Details finden Sie unter cursor.com/pricing.

Gemma 4 lokal mit Ollama ausführen: Eine vollständige Anleitung

Emre Demir — Fri, 03 Apr 2026 02:53:58 +0000

Kurz gesagt

Gemma 4 wurde am 3. April 2026 veröffentlicht, und Ollama v0.20.0 fügte noch am selben Tag Unterstützung hinzu. Sie können das Standardmodell gemma4:e4b in zwei Befehlen herunterladen und ausführen. Dieser Leitfaden führt Sie durch die Einrichtung, Modellauswahl, API-Nutzung und wie Sie Ihre lokalen Gemma 4 Endpunkte mit Apidog testen.

Testen Sie Apidog noch heute

Einleitung

Google veröffentlichte Gemma 4 am 2. April 2026. Innerhalb von 24 Stunden lieferte Ollama v0.20.0 mit vollständiger Unterstützung für alle vier Modellvarianten aus.

Für Entwickler ist das wichtig. Gemma 4 ist keine kleine Verbesserung. Es erreicht 89,2 % beim AIME 2026, verglichen mit 20,8 % bei Gemma 3. Die Bewertung im Coding-Benchmark stieg von 110 ELO auf 2150 bei Codeforces. Sie erhalten natives Funktions-Calling, konfigurierbare Denkmodi und ein 256K Kontextfenster bei den größeren Varianten. All dies läuft auf Ihrer eigenen Hardware.

Wenn Sie API-gestützte Apps entwickeln, ermöglicht das lokale Setup eine schnelle, private KI-Schicht zum Generieren von Mock-Daten, Schreiben von Testszenarien und Validieren von API-Antworten, ohne Daten an einen Remote-Server zu senden.

💡 Sobald Gemma 4 lokal läuft, kann Apidogs Smart Mock realistische API-Antwortdaten aus Ihrem Schema generieren, unter Verwendung derselben Art von KI-gestützter Inferenz. Sie definieren die Form Ihrer API einmal; Apidog übernimmt die Mock-Daten. Das passt gut zu lokalen Modell-Experimenten, bei denen Sie konsistente, schema-konforme Testdaten wünschen, ohne Fixtures manuell schreiben zu müssen.

Dieser Leitfaden deckt alles ab, von der Installation bis zum ersten lokalen API-Aufruf.

Was ist neu in Gemma 4

Gemma 4 wird mit vier Modellvarianten mit deutlich unterschiedlichen Fähigkeiten ausgeliefert.

Das unterscheidet es von Gemma 3:

Argumentation und Codierung. Das 31B-Modell erreicht 80 % auf LiveCodeBench v6. Das frühere Gemma 3 27B erreichte 29,1 %.
Mixture-of-Experts-Architektur (MoE). Die 26B-Variante verwendet MoE mit nur 4 Milliarden aktiven Parametern während der Inferenz.
Längerer Kontext. E2B und E4B unterstützen 128K Token; 26B/31B bieten 256K.
Natives Funktions-Calling. Alle Modelle unterstützen strukturierte Tool-Nutzung out-of-the-box.
Audio- und Bildeingabe. E2B/E4B akzeptieren Audio- und Bilddaten.
Denkmodi. Chain-of-Thought kann pro Anfrage an- oder ausgeschaltet werden.

Gemma 4 Modellvarianten erklärt

Vor dem Download: Wählen Sie das Modell passend zu Ihrer Hardware.

Modell	Größe auf Festplatte	Kontext	Architektur	Am besten geeignet für
`gemma4:e2b`	7.2 GB	128K	Dense	Laptops, Edge, Audio/Bild
`gemma4:e4b`	9.6 GB	128K	Dense	Die meisten Entwickler
`gemma4:26b`	18 GB	256K	MoE (4B aktiv)	Beste Qualität pro GB
`gemma4:31b`	20 GB	256K	Dense	Maximale Qualität

Das e4b-Modell ist die Standardeinstellung bei ollama run gemma4. Es läuft auf Consumer-GPUs ab 10+ GB VRAM und Apple Silicon.

Die 26b MoE-Variante ist optimal für hohe Qualität bei geringeren Ressourcen (~20+ GB RAM).

Voraussetzungen

Ollama v0.20.0+ ist erforderlich.

Version prüfen:

ollama --version

Aktualisieren:

# macOS
brew upgrade ollama

# Linux
curl -fsSL https://ollama.com/install.sh | sh

Windows: Installer herunterladen.

Hardware-Anforderungen:

gemma4:e2b: min. 8 GB RAM (16 GB empfohlen)
gemma4:e4b: 10 GB VRAM oder 16 GB Unified Memory
gemma4:26b: 20+ GB RAM/Unified Memory
gemma4:31b: 24 GB VRAM oder 32 GB Unified Memory

Gemma 4 installieren und ausführen

Standardmodell herunterladen und ausführen:

ollama run gemma4

Beim ersten Start werden ~9,6 GB geladen. Testen Sie direkt:

>>> Welche HTTP-Statuscodes gibt es für Clientfehler?

Spezifische Varianten:

# Edge-Modell
ollama run gemma4:e2b

# MoE-Modell
ollama run gemma4:26b

# Flaggschiff
ollama run gemma4:31b

Vorab nur herunterladen:

ollama pull gemma4
ollama pull gemma4:26b

Verfügbare Modelle listen:

ollama list

Die lokale Gemma 4 API verwenden

Ollama stellt unter http://localhost:11434 eine lokale REST-API bereit.

Vervollständigung generieren

curl http://localhost:11434/api/generate \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4",
    "prompt": "Schreiben Sie eine JSON-Antwort für einen API-Endpunkt für Benutzerprofile",
    "stream": false
  }'

Chat-Vervollständigung (OpenAI-kompatibel)

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4",
    "messages": [
      {
        "role": "user",
        "content": "Generieren Sie einen realistischen JSON-Mock für eine E-Commerce-Bestellungs-API-Antwort"
      }
    ]
  }'

Python-Client

import requests

def ask_gemma4(prompt: str, model: str = "gemma4"):
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "stream": False
        }
    )
    response.raise_for_status()
    return response.json()["response"]

result = ask_gemma4("Listen Sie die Felder auf, die eine Zahlungs-API-Antwort enthalten sollte")
print(result)

OpenAI Python SDK

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {
            "role": "system",
            "content": "Sie generieren realistische API-Antwortdaten im JSON-Format."
        },
        {
            "role": "user",
            "content": "Generieren Sie eine Beispielantwort für einen GET /users/{id} Endpunkt"
        }
    ]
)

print(response.choices[0].message.content)

Funktions-Calling mit Gemma 4 verwenden

Gemma 4 unterstützt natives Funktions-Calling: Definieren Sie ein Tool-Schema und erhalten Sie strukturiertes JSON passend zu Ihrer Funktionssignatur.

Beispiel:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_user",
            "description": "Einen Benutzer anhand der ID von der API abrufen",
            "parameters": {
                "type": "object",
                "properties": {
                    "user_id": {
                        "type": "integer",
                        "description": "Die eindeutige Benutzer-ID"
                    },
                    "include_orders": {
                        "type": "boolean",
                        "description": "Ob die Bestellhistorie enthalten sein soll"
                    }
                },
                "required": ["user_id"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {"role": "user", "content": "Benutzer 42 mit seiner Bestellhistorie abrufen"}
    ],
    tools=tools,
    tool_choice="auto"
)

tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.function.name)       # get_user
print(tool_call.function.arguments)  # {"user_id": 42, "include_orders": true}

Das Modell extrahiert automatisch die Parameter und liefert ein gültiges JSON-Objekt.

Denkmodus aktivieren

Für komplexe Aufgaben wie Testszenarien oder API-Spezifikationsanalyse aktivieren Sie die Chain-of-Thought-Argumentation:

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {
            "role": "user",
            "content": "Entwerfen Sie ein vollständiges Testszenario für eine Zahlungsabwicklungs-API mit Randfällen"
        }
    ],
    extra_body={"think": True}
)

print(response.choices[0].message.content)

Für einfache Prompts deaktivieren Sie den Denkmodus, um Latenz zu vermeiden.

Gemma 4 API-Antworten mit Apidog testen

Sobald Ihre lokale Gemma 4 Instanz läuft, können Sie die API-Endpunkte systematisch mit Apidog testen.

1. Ollama API-Spezifikation importieren: Erstellen Sie ein neues Projekt in Apidog und fügen Sie die Basis-URL http://localhost:11434 hinzu.

2. Endpunkte definieren:

POST /api/generate für Single-Turn-Vervollständigungen
POST /v1/chat/completions für Multi-Turn-Chat
GET /api/tags um verfügbare Modelle zu listen

3. Testszenario einrichten: Verbinden Sie mehrere Anfragen mit Assertionen:

GET /api/tags – prüft, dass gemma4 gelistet ist
POST /api/generate – prüft, dass das response-Feld nicht leer ist
POST /v1/chat/completions – validiert das Antwortformat

Nutzen Sie den Extract Variable Prozessor von Apidog, um Antworten zwischen Schritten weiterzugeben und Multi-Turn-Flows zu testen.

4. Antwort-Schemas validieren: Apidogs Contract Testing validiert API-Antworten gegen Ihre OpenAPI-Spezifikation. Definieren Sie das erwartete Antwortschema und testen Sie nach Modell-Updates auf breaking changes.

5. Smart Mock für parallele Entwicklung: Mit Smart Mock generiert Apidog automatisch schema-konforme Antworten, sodass Frontend-Teams unabhängig vom Modellstand arbeiten können.

Multimodale Eingabe mit Gemma 4

E2B/E4B-Modelle akzeptieren Bilder als base64-kodierte Strings:

import base64

with open("api_diagram.png", "rb") as f:
    image_data = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="gemma4:e4b",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{image_data}"
                    }
                },
                {
                    "type": "text",
                    "text": "Beschreiben Sie den in diesem Diagramm gezeigten API-Flow und identifizieren Sie potenzielle Fehlerpfade"
                }
            ]
        }
    ]
)

Ideal zur Analyse von Architekturdiagrammen, API-Doku-Screenshots oder zur Bilddaten-Extraktion.

Häufige Probleme und Lösungen

Modell nicht gefunden: Führen Sie ollama pull gemma4 aus oder prüfen Sie mit ollama list.
Langsame Inferenz auf CPU: Nutzen Sie gemma4:e2b für bessere CPU-Performance.
Speicherfehler: Prüfen Sie VRAM/Memory mit ollama ps. Wechseln Sie ggf. auf kleinere Modelle.
Apple Silicon-Ladeprobleme: Ollama 0.20.0 unterstützt MLX; aktualisieren Sie ggf.
Port belegt: Starten Sie mit anderem Port: OLLAMA_HOST=0.0.0.0:11435 ollama serve.
Abgeschnittene Antworten: Erhöhen Sie das Kontextfenster: "options": {"num_ctx": 8192} im JSON-Body.

Gemma 4 vs. andere lokale Modelle

Modell	Beste Größe	Kontext	Funktions-Calling	Coding-Benchmark
Gemma 4	e4b (9.6 GB)	128K-256K	Nativ	80% LiveCodeBench
Llama 3.3	70B-Q4 (40 GB)	128K	Nativ	~60% LiveCodeBench
Qwen3.6-Plus	72B-Q4 (44 GB)	128K	Nativ	Stark
Mistral Small	24B (14 GB)	128K	Nativ	Moderat

Besonders die MoE-Variante (26b) von Gemma 4 liefert mit 18 GB Speicher nahezu Flaggschiff-Qualität bei hoher Geschwindigkeit.

Fazit

Gemma 4 mit Ollama ist eines der leistungsfähigsten lokalen Setups für Entwickler. Die Installation dauert zwei Befehle, das Standardmodell läuft auf den meisten Maschinen. Der Qualitätsgewinn gegenüber Gemma 3 ist signifikant.

Starten Sie mit ollama run gemma4, testen Sie Ihre Endpunkte mit Apidog, und wählen Sie das passende Modell gemäß Tabelle.

Für Teams, die auf Gemma 4 aufbauen, ermöglicht die Kombination aus lokaler Inferenz, Apidogs Smart Mock und Testszenarien einen vollständigen, unabhängigen Entwicklungszyklus.

FAQ

Wie aktualisiere ich Gemma 4 in Ollama, wenn eine neue Version herauskommt?

Führen Sie ollama pull gemma4 erneut aus. Ollama lädt nur Änderungen.

Kann ich Gemma 4 auf einem Computer ohne GPU ausführen?

Ja, aber langsam. Mit CPU erreichen Sie 1–3 Tokens/Sekunde (e2b empfohlen).

Was ist der Unterschied zwischen gemma4:e2b und gemma4:e4b?

Beide sind dichte Edge-Modelle. E4B ist größer und besser für komplexe Aufgaben, E2B ist kleiner und unterstützt Audio.

Funktioniert Gemma 4 mit LangChain und LlamaIndex?

Ja. Beide Frameworks unterstützen Ollama als Backend (http://localhost:11434, Modellname gemma4).

Ist die lokale Gemma 4 API kompatibel mit Code für die OpenAI API?

Meistens ja. Nutzen Sie /v1/chat/completions, ändern Sie base_url und verwenden Sie einen beliebigen api_key.

Wie verwende ich den Denkmodus von Gemma 4?

Übergeben Sie "think": true im extra_body-Parameter beim OpenAI SDK oder direkt im JSON-Body.

Kann ich Gemma 4 anderen Maschinen im Netzwerk bereitstellen?

Ja, starten Sie Ollama mit OLLAMA_HOST=0.0.0.0:11434 ollama serve.

Welches ist das beste Gemma 4 Modell für API-Entwicklungsaufgaben?

Für Mock-Daten und Tests: e4b. Für komplexe Analysen: 26b (MoE).

Gemma 4 als API Backend betreiben

Emre Demir — Fri, 03 Apr 2026 02:41:43 +0000

TL;DR: Google hat im April 2026 Gemma 4 veröffentlicht – eine offene Familie von vier Modellen unter Apache 2.0, die auf Standard-Benchmarks Modelle übertreffen, die 20-mal größer sind. Sie können die Gemma 4 API über Google AI Studio, Vertex AI oder lokal mit Ollama und vLLM nutzen. Mit Apidogs Smart Mock generieren Sie automatisch realistische API-Antworten aus Ihren OpenAPI-Schemata, ohne eigene Mock-Regeln schreiben zu müssen.

Testen Sie Apidog noch heute

Einleitung

Die meisten Open-Source-KI-Modelle erfordern einen Kompromiss: Entweder viel Leistung oder einfache Bereitstellung. Große Modelle laufen nicht lokal, kleine Modelle liefern schwache Ergebnisse bei komplexen Aufgaben. Gemma 4 durchbricht diesen Kompromiss.

Gemma 4 ist Googles leistungsstärkste offene Modellfamilie. Das 31B Dense Modell liegt auf Platz 3 aller offenen Modelle bei Arena AI und schlägt viele 20-mal größere Modelle. Das 26B MoE erreicht Platz 6. Beide laufen auf einer 80-GB-GPU. Die E2B- und E4B-Modelle funktionieren komplett offline auf Smartphones und Edge-Geräten.

Für API-Entwickler relevant: Gemma 4 unterstützt nativ Funktionsaufrufe, strukturierte JSON-Ausgabe und große Kontextfenster (bis 256K Token). Ideal für KI-gestützte API-Tools – von Testdatengenerierung über Mocking bis zur API-Antwortanalyse.

💡Wenn Sie mit Gemma 4 arbeiten und KI-Antworten nach OpenAPI-Spezifikation validieren müssen, generiert Apidogs Smart Mock Engine automatisch schema-konforme Mock-Antworten. Keine individuellen Mock-Regeln nötig – Smart Mock liest Ihr Schema und liefert passende Daten. Laden Sie Apidog kostenlos herunter und integrieren Sie es in Ihren Gemma 4 API-Workflow.

Was ist Gemma 4 und was ist neu?

Gemma 4 ist die vierte Generation offener Sprachmodelle von Google DeepMind. Seit dem Start 2024 wurden Gemma-Modelle über 400 Millionen Mal heruntergeladen, die Community hat über 100.000 Varianten gebaut – das „Gemmaverse“.

Gemma 4 ist unter Apache 2.0-Lizenz veröffentlicht. Sie können das Modell kommerziell nutzen, verändern und weitergeben – ohne Einschränkungen. Wichtig für Unternehmen, die volle Kontrolle benötigen.

Wichtigste Neuerung: „Intelligenz pro Parameter“. Das 31B Dense Modell liefert Top-Leistung zu einem Bruchteil der Kosten von GPT-4 oder Claude 3 Sonnet. Auf Arena AI schlägt Gemma 4 31B sogar 600B-Parameter-Modelle.

Die wichtigsten Neuerungen gegenüber Gemma 3:

Native multimodale Eingabe: Alle Gemma 4 Modelle verarbeiten Bilder und Videos, E2B/E4B zusätzlich Audio.
Längere Kontextfenster: E2B/E4B: 128K Token, 26B/31B: 256K Token – genug für ganze Repos.
Agenten-Workflows: Native Funktionsaufrufe, strukturierte JSON-Ausgabe und System-Prompts.
Fortgeschrittene Argumentation: Das 31B-Modell ist deutlich besser in Mathematik und multistep Reasoning.
140+ Sprachen: Nativ trainiert, nicht nur aus Englisch übersetzt.
Apache 2.0-Lizenz: Volle rechtliche Klarheit für kommerzielle Nutzung.

Gemma 4 Modellvarianten und Fähigkeiten

Vier Größen – für verschiedene Hardware:

Modell	Parameter	Aktive Parameter (Inferenz)	Kontext	Am besten geeignet für
E2B	Effektive 2B	~2B	128K	Mobil, IoT, Offline-Edge
E4B	Effektive 4B	~4B	128K	Telefone, Raspberry Pi, Jetson Orin
26B MoE	26B gesamt	~3.8B aktiv	256K	Latenzempfindliche Serveraufgaben
31B Dense	31B	31B	256K	Höchste Qualität, Forschung, Fine-Tuning

E2B/E4B setzen auf Mixture-of-Experts: Nur ein Bruchteil der Parameter wird pro Token genutzt. Entwickelt mit Qualcomm/MediaTek, laufen sie offline auf Android (AICore Preview).

26B MoE aktiviert nur 3,8B Parameter pro Inferenz, ideal für schnelle Server-Deployments.

31B Dense ist der Qualitätsführer – optimal fürs Fine-Tuning und domänenspezifische Aufgaben.

Für API-Tools ist 26B MoE meist das beste Verhältnis aus Geschwindigkeit und Qualität, 31B Dense für komplexe, strukturierte JSON-Ausgaben. Alle Modelle unterstützen Funktionsaufrufe und JSON-Ausgabe.

Gemma 4 API einrichten: Schritt für Schritt

Drei Wege zur Nutzung: Google AI Studio (am schnellsten), Vertex AI (Enterprise) oder lokal mit Ollama/vLLM.

Option 1: Google AI Studio (Prototyping)

1. Gehen Sie zu Google AI Studio und erstellen Sie ein (kostenloses) Konto. Generieren Sie einen API-Key.

2. Installieren Sie das SDK:

pip install google-genai

3. Erster API-Aufruf:

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel("gemma-4-31b-it")

response = model.generate_content(
    "Generate a JSON object for a user account with id, email, and created_at fields."
)

print(response.text)

4. Für strukturierte JSON-Ausgabe:

import google.generativeai as genai
import json

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel(
    "gemma-4-31b-it",
    generation_config={"response_mime_type": "application/json"}
)

prompt = """
Generate 3 sample user objects for an e-commerce API. 
Each user should have: id (integer), email (string), username (string), 
created_at (ISO 8601 timestamp), and subscription_tier (free|pro|enterprise).
Return as a JSON array.
"""

response = model.generate_content(prompt)
users = json.loads(response.text)
print(json.dumps(users, indent=2))

Option 2: Lokale Bereitstellung mit Ollama

1. Installieren Sie Ollama von ollama.com. Laden Sie das Modell:

ollama pull gemma4

2. Starten Sie den Server:

ollama serve

3. OpenAI-kompatibler API-Call:

import requests
import json

response = requests.post(
    "http://localhost:11434/api/chat",
    json={
        "model": "gemma4",
        "messages": [
            {
                "role": "user",
                "content": "Generate a valid JSON response for a REST API /products endpoint. Include id, name, price, and stock fields."
            }
        ],
        "stream": False
    }
)

result = response.json()
print(result["message"]["content"])

Option 3: Funktionsaufrufe für API-Orchestrierung

Mit Funktionsaufrufen können Sie Tools definieren, die das Modell gezielt aufruft:

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

tools = [
    {
        "function_declarations": [
            {
                "name": "get_api_schema",
                "description": "Retrieve the OpenAPI schema for a given endpoint path",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "endpoint_path": {
                            "type": "string",
                            "description": "The API endpoint path, e.g. /users/{id}"
                        },
                        "method": {
                            "type": "string",
                            "enum": ["GET", "POST", "PUT", "DELETE", "PATCH"]
                        }
                    },
                    "required": ["endpoint_path", "method"]
                }
            }
        ]
    }
]

model = genai.GenerativeModel("gemma-4-31b-it", tools=tools)

response = model.generate_content(
    "I need to test the GET /users/{id} endpoint. What schema should the response follow?"
)

if response.candidates[0].content.parts[0].function_call:
    fc = response.candidates[0].content.parts[0].function_call
    print(f"Model called function: {fc.name}")
    print(f"With args: {dict(fc.args)}")

Dieses Funktionsaufruf-Muster ist optimal für agentenbasierte API-Testpipelines.

Erstellen von KI-gestützten API-Mocks mit Gemma 4

Nutzen Sie Gemma 4, um realistische Mock-Daten direkt aus einem OpenAPI-Schema zu generieren:

import google.generativeai as genai
import json

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel(
    "gemma-4-31b-it",
    generation_config={"response_mime_type": "application/json"}
)

schema = {
    "type": "object",
    "properties": {
        "id": {"type": "integer"},
        "order_number": {"type": "string", "pattern": "^ORD-[0-9]{6}$"},
        "status": {"type": "string", "enum": ["pending", "shipped", "delivered", "cancelled"]},
        "total": {"type": "number", "minimum": 0},
        "items": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "product_id": {"type": "integer"},
                    "quantity": {"type": "integer", "minimum": 1},
                    "unit_price": {"type": "number"}
                }
            }
        },
        "created_at": {"type": "string", "format": "date-time"}
    }
}

prompt = f"""
Generate 5 realistic mock responses for an order management API.
Each response must conform exactly to this JSON Schema:
{json.dumps(schema, indent=2)}

Make the data realistic: use realistic prices, product IDs, and varied statuses.
Return as a JSON array of 5 order objects.
"""

response = model.generate_content(prompt)
mock_orders = json.loads(response.text)
print(json.dumps(mock_orders, indent=2))

Gemma 4 versteht JSON-Schema-Einschränkungen (Enum, Muster etc.) und liefert passende Mock-Daten – ideal für echtes API-Mocking.

Sie können für jeden Endpunkt Ihres OpenAPI-Schemas Mocks generieren. Für komplexe Fälle können Sie die komplette Spezifikation als Prompt einbinden – dank 256K Kontextfenster auch für große APIs.

Effizienter Workflow: Exportieren Sie Ihre Apidog-Sammlung als OpenAPI, prompten Sie Gemma 4 und erhalten Sie automatisch pro Endpunkt realistische Testfälle.

Testen von Gemma 4 API-Antworten mit Apidog

Nach der Generierung von Testdaten/API-Antworten mit Gemma 4 sollten Sie das Ergebnis gegen Ihr Schema validieren. Hier kommt Apidogs Test-Szenario-Modul ins Spiel.

Schritt-für-Schritt-Workflow:

Endpunkt importieren: In Apidog neuen Endpunkt anlegen, auf Ihren Gemma 4 Wrapper oder direkt Google AI Studio zeigen. Antwortschema definieren.
Smart Mock verwenden: Mit Apidogs Smart Mock automatisch realistische Antworten aus dem Schema generieren lassen.
Testszenario anlegen: Im „Tests“-Modul ein Szenario erstellen, Gemma 4 API-Aufruf als Schritt hinzufügen, dann Assertions.
Assertions konfigurieren: Prüfen Sie Statuscode, Header und v.a. das JSON-Feld candidates[0].content.parts[0].text. Extrahieren Sie per „Extract Variable“-Prozessor die KI-Ausgabe und nutzen Sie sie in Folgeschritten.
Datengesteuertes Testen: CSV/JSON-Testdaten importieren, z.B. 50 Prompt-Varianten gleichzeitig testen – ideal für robuste API-Workflows.

Die Einrichtung dauert ca. 15 Minuten, danach können Sie den Workflow automatisiert in Ihrer CI/CD-Pipeline (über Apidog CLI) nutzen.

Praktische Anwendungsfälle

API-Testdatengenerierung: Mit Gemma 4s JSON-Modus & OpenAPI-Schema in Minuten Hunderte realistische Testdatensätze erstellen.
Intelligentes API-Mocking: Kontextuelle Mocks, z.B. für Produktsuch-APIs, ohne jeden Fall hardcoden zu müssen.
API-Dokumentationsgenerierung: 256K Kontext erlaubt komplette Codebasen als Prompt, inkl. automatischer OpenAPI-Spezifikation durch Funktionsaufrufe.
Antwortschema-Validierung: KI-Analyse von API-Antworten, inkl. Schemaverletzungen und komplexer Fehlererkennung.
Automatisiertes Schreiben von Regressionstests: Gemma 4 kann auf Basis Ihrer API-Spezifikation und Fehlerreports gezielt Testfälle erzeugen, die echte Fehler abfangen.

Gemma 4 im Vergleich zu anderen offenen Modellen für die API-Nutzung

Modell	Parameter	Kontext	JSON-Ausgabe	Funktionsaufruf	Lizenz
Gemma 4 31B	31B	256K	Nativ	Nativ	Apache 2.0
Gemma 4 26B MoE	26B (3.8B aktiv)	256K	Nativ	Nativ	Apache 2.0
Llama 3.3 70B	70B	128K	Über Prompt	Über Prompt	Llama Community
Mistral 7B	7B	32K	Über Prompt	Begrenzt	Apache 2.0
Qwen 2.5 72B	72B	128K	Nativ	Nativ	Apache 2.0

Kritisch für API-Tools: nativer JSON-Modus, Funktionsaufruf, Kontextlänge. Gemma 4 26B/31B bieten alles. Llama 3.3 70B benötigt doppelt so viel Hardware wie Gemma 4 31B, bietet aber keine native JSON- oder Funktionsaufruf-Unterstützung. Mistral 7B ist sehr schnell, aber das Kontextfenster ist zu klein für große APIs. Qwen 2.5 72B ist stark, braucht aber viel Hardware.

Die Apache 2.0-Lizenz von Gemma 4 bietet volle Rechtssicherheit, was bei Llama (Community License) nicht immer gegeben ist.

Empfehlung: Für die meisten API-Entwicklungen starten Sie mit Gemma 4 26B MoE (Latenz) oder 31B (Qualität).

Fazit

Gemma 4 ist eine offene, leistungsfähige Alternative zu proprietären KI-APIs im API-Tooling. Dank Apache 2.0-Lizenz und nativer Funktionsaufrufe/JSON-Modus ist die Integration in API-Workflows ohne komplexes Prompt Engineering direkt möglich.

Vier Modellgrößen erlauben flexible Hardware-Auswahl. Das 26B MoE Modell ist optimal für schnelle, skalierbare API-Entwicklung.

Kombinieren Sie Gemma 4 mit Apidog, um KI-generierte Daten effizient zu validieren. Nutzen Sie Gemma 4 für Testdatengenerierung, Apidogs Smart Mock zum Prototypen und deren Testszenarien für die Validierung. Damit bauen Sie robuste, KI-gestützte APIs mit minimalem Aufwand.

FAQ

Was ist Gemma 4? Gemma 4 ist Google DeepMinds neueste Familie offener Sprachmodelle (E2B, E4B, 26B MoE, 31B Dense, Apache 2.0), veröffentlicht April 2026. Das 31B-Modell ist auf Platz 3 der Arena AI Bestenliste.

Ist Gemma 4 kostenlos nutzbar? Die Modellgewichte sind unter Apache 2.0 frei nutzbar; Sie zahlen nur für Rechenleistung (Google AI Studio: Freistufe mit Limits, Vertex AI: Cloud-Raten).

Kann Gemma 4 strukturiertes JSON ausgeben? Ja, via response_mime_type: "application/json" im Google Generative AI SDK. Für APIs essenziell.

Wie schneidet Gemma 4 im Vergleich zu GPT-4o bei der API-Entwicklung ab? GPT-4o ist proprietär, kein On-Prem-Hosting, höhere API-Kosten. Gemma 4 31B kann lokal und kostenlos laufen und ist bei Reasoning-Benchmarks konkurrenzfähig.

Kann ich Gemma 4 mit eigenen API-Daten feinabstimmen? Ja, Fine-Tuning über Google AI Studio, Vertex AI oder Drittanbieter-Tools wie Hugging Face TRL möglich – besonders für domänenspezifische APIs sinnvoll.

Welche Hardware benötige ich für lokale Nutzung? 31B/26B laufen auf einer 80-GB-NVIDIA H100 (bfloat16). Quantisierte Versionen laufen auf Consumer-GPUs (16–24 GB VRAM). E4B/E2B laufen auf Smartphones, Raspberry Pi, Jetson.

Unterstützt Gemma 4 Funktionsaufrufe? Ja, alle Modelle. Tools werden als JSON deklariert, das Modell ruft sie kontextgesteuert auf und gibt strukturierte Argumente aus.

Wie teste ich Gemma 4 API-Antworten automatisch? Mit Apidogs Testszenarien: Endpunkt importieren, Anfrageschritte definieren, Assertions hinzufügen, Szenario lokal/CLI/CI ausführen.

Qwen3.6-Plus API: Besser als Claude bei Terminal Benchmarks

Emre Demir — Thu, 02 Apr 2026 09:36:17 +0000

Kurz gesagt

Qwen3.6-Plus wurde offiziell veröffentlicht. Es erreicht 78,8 % auf SWE-bench Verified und 61,6 % auf Terminal-Bench 2.0, womit es Claude Opus 4.5 übertrifft. Es verfügt über ein Kontextfenster von 1 Million Tokens, einen neuen preserve_thinking Parameter für Agenten-Loops und arbeitet direkt mit Claude Code, OpenClaw und Qwen Code über eine OpenAI-kompatible API.

Probiere Apidog noch heute aus

Von der Vorschau zur Veröffentlichung

Wenn Sie unseren früheren Leitfaden zur Qwen 3.6 Plus Vorschau auf OpenRouter gelesen haben, kennen Sie bereits die Fähigkeiten des Modells. Die Vorschau wurde am 30. März ohne Warteliste und kostenlos über OpenRouter veröffentlicht. In den ersten zwei Tagen wurden über 400 Millionen Completion-Tokens in ca. 400.000 Anfragen verarbeitet.

Mit der offiziellen Veröffentlichung steht jetzt die Produktionsversion bereit. Qwen3.6-Plus ist über das Alibaba Cloud Model Studio mit stabiler API, SLA-gestützter Betriebszeit und einem neuen API-Parameter für komplexe Agentenaufgaben verfügbar.

In diesem Leitfaden erfahren Sie, was sich geändert hat, wie Sie die API korrekt aufrufen und wie Sie Ihre Integration mit Apidog vor der Bereitstellung testen.

Was Qwen3.6-Plus ist

Qwen3.6-Plus ist ein gehostetes Mixture-of-Experts-Modell des Qwen-Teams von Alibaba. Wie Qwen3.5 nutzt es dünne Aktivierung – pro Token wird nur ein Teil der Parameter aktiviert. Das sorgt für starke Leistung bei geringeren Rechenkosten verglichen mit ähnlich starken dichten Modellen.

Wichtige Spezifikationen:

1M Token Kontextfenster (Standard)
Obligatorische Chain-of-Thought-Argumentation
Neuer preserve_thinking Parameter für Agentenaufgaben
Native multimodale Unterstützung (Vision, Video, Dokumente)
OpenAI-kompatible API, Anthropic-kompatible API und OpenAI Responses API

Open-Source-Varianten erscheinen in Kürze. Wer Gewichte für Self-Hosting benötigt, kann diese bald erwarten.

Benchmark-Ergebnisse

Coding-Agenten

Qwen3.6-Plus liegt bei SWE-bench-Aufgaben knapp hinter Claude Opus 4.5, übertrifft aber alle Modelle bei Terminaloperationen.

Terminal-Bench 2.0 testet echte Shell-Operationen: Dateimanagement, Prozesskontrolle, mehrstufige Workflows (3h Timeout, 32 CPUs, 48 GB RAM). Qwen3.6-Plus erreicht 61,6 % (Claude Opus 4.5: 59,3 %) – ein klarer Vorteil bei Entwickleraufgaben.

Allgemeine Agenten und Werkzeugnutzung

Benchmark	Claude Opus 4.5	Qwen3.6-Plus
TAU3-Bench	70.2%	70.7%
DeepPlanning	33.9%	41.5%
MCPMark	42.3%	48.2%
MCP-Atlas	71.8%	74.1%
WideSearch	76.4%	74.3%

MCPMark prüft GitHub MCP Tool-Aufrufe. Qwen3.6-Plus führt mit 48,2 %, DeepPlanning mit 41,5 % (Claude: 33,9 %) zeigt die Stärke bei langfristigen Planungsaufgaben.

Argumentation und Wissen

Benchmark	Claude Opus 4.5	Qwen3.6-Plus
GPQA	87.0%	90.4%
LiveCodeBench v6	84.8%	87.1%
IFEval strict	90.9%	94.3%
MMLU-Pro	89.5%	88.5%

GPQA testet wissenschaftliche Argumentation. IFEval strict misst, wie präzise Formatierungen befolgt werden. Qwen3.6-Plus führt in beiden – entscheidend für strukturierte Ausgaben und komplexe Agentenaufgaben.

Multimodal

Qwen3.6-Plus ist von Haus aus multimodal und führt bei Benchmarks für Dokumente, räumliche und Objekterkennung.

Benchmark	Qwen3.6-Plus	Anmerkungen
OmniDocBench 1.5	91.2%	Spitzenwert in Tabelle
RefCOCO avg	93.5%	Spitzenwert in Tabelle
We-Math	89.0%	Spitzenwert in Tabelle
CountBench	97.6%	Spitzenwert in Tabelle
OSWorld-Verified	62.5%	Hinter Claude (66,3 %)

Bei Dokumentenverständnis und räumlicher Verankerung ist Qwen3.6-Plus führend.

Wie man die API aufruft

Qwen3.6-Plus ist im Alibaba Cloud Model Studio verfügbar. Ihren API-Schlüssel erhalten Sie unter modelstudio.alibabacloud.com.

Drei regionale Basis-URLs:

Singapur: https://dashscope-intl.aliyuncs.com/compatible-mode/v1
Peking: https://dashscope.aliyuncs.com/compatible-mode/v1
US Virginia: https://dashscope-us.aliyuncs.com/compatible-mode/v1

Grundlegender Aufruf mit Streaming

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["DASHSCOPE_API_KEY"],
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)

completion = client.chat.completions.create(
    model="qwen3.6-plus",
    messages=[{"role": "user", "content": "Review this Python function and find bugs."}],
    extra_body={"enable_thinking": True},
    stream=True
)

reasoning = ""
answer = ""
is_answering = False

for chunk in completion:
    if not chunk.choices:
        continue
    delta = chunk.choices[0].delta
    if hasattr(delta, "reasoning_content") and delta.reasoning_content:
        if not is_answering:
            reasoning += delta.reasoning_content
    if delta.content:
        if not is_answering:
            is_answering = True
        answer += delta.content
        print(delta.content, end="", flush=True)

Der `preserve_thinking` Parameter

Mit der offiziellen Version steht preserve_thinking zur Verfügung.

Setzen Sie preserve_thinking: true, um die komplette Chain-of-Thought aus allen bisherigen Zügen in der Konversation zu erhalten. Besonders für mehrstufige Agententasks empfohlen. Standardmäßig deaktiviert (spart Tokens). Für Agenten-Loops aktivieren:

completion = client.chat.completions.create(
    model="qwen3.6-plus",
    messages=conversation_history,
    extra_body={
        "enable_thinking": True,
        "preserve_thinking": True, # reasoning über alle Züge hinweg behalten
    },
    stream=True
)

Qwen3.6-Plus mit Claude Code verwenden

Die Qwen API unterstützt das Anthropic-Protokoll. Claude Code kann direkt gegen Qwen3.6-Plus laufen, nur Umgebungsvariablen anpassen:

npm install -g @anthropic-ai/claude-code

export ANTHROPIC_MODEL="qwen3.6-plus"
export ANTHROPIC_SMALL_FAST_MODEL="qwen3.6-plus"
export ANTHROPIC_BASE_URL=https://dashscope-intl.aliyuncs.com/apps/anthropic
export ANTHROPIC_AUTH_TOKEN=your_dashscope_api_key

claude

Qwen3.6-Plus mit OpenClaw verwenden

OpenClaw (früher Moltbot / Clawdbot) ist ein quelloffener, selbst gehosteter Coding-Agent. Installation und Konfiguration:

# Install (Node.js 22+)
curl -fsSL https://molt.bot/install.sh | bash

export DASHSCOPE_API_KEY=your_key
openclaw dashboard

Bearbeite ~/.openclaw/openclaw.json und ergänze:

{
  "models": {
    "providers": [{
      "name": "alibaba-coding-plan",
      "baseUrl": "https://coding-intl.dashscope.aliyuncs.com/v1",
      "apiKey": "${DASHSCOPE_API_KEY}",
      "models": [{"id": "qwen3.6-plus", "reasoning": true}]
    }]
  },
  "agents": {
    "defaults": {"models": ["qwen3.6-plus"]}
  }
}

Qwen3.6-Plus mit Qwen Code verwenden

Qwen Code ist Alibabas Open-Source-Terminal-Agent, speziell für Qwen-Modelle. Mit OAuth gibt es 1.000 kostenlose API-Calls/Tag.

npm install -g @qwen-code/qwen-code@latest
qwen
# Tippe /auth für Login und Freischaltung der Free-Tier

Warum `preserve_thinking` das Agentenverhalten ändert

Ohne preserve_thinking behandelt die LLM-API jeden Zug isoliert – nützlich für einfache Q&A, aber nicht für mehrschrittige Agenten. Mit preserve_thinking bleibt die gesamte Argumentationskette sichtbar. Ein Agent kann in Schritt 8 noch auf die Analyse aus Schritt 2 referenzieren.

Alibabas Benchmarks zeigen: Weniger redundante Argumentation, geringerer Tokenverbrauch pro Zug bei komplexen Workflows.

Beispiel für Agenten-Loops:

conversation = []

def agent_step(user_message, preserve=True):
    conversation.append({"role": "user", "content": user_message})

    response = client.chat.completions.create(
        model="qwen3.6-plus",
        messages=conversation,
        extra_body={
            "enable_thinking": True,
            "preserve_thinking": preserve,
        },
        stream=False
    )

    message = response.choices[0].message
    conversation.append({"role": "assistant", "content": message.content})
    return message.content

# Beispiel: Multi-Step Code Review Agent
result = agent_step("Analyze the auth module for security issues.")
result = agent_step("Now suggest fixes for the top 3 issues you found.")
result = agent_step("Write tests that validate each fix.")

Ohne preserve_thinking weiß das Modell in Schritt 3 nicht mehr, welche 3 Probleme es in Schritt 1 gefunden hat. Mit Parameter bleibt der Kontext erhalten.

Wofür es am besten geeignet ist

Fehlerbehebung auf Repository-Ebene: SWE-bench Verified (78,8 %) und SWE-bench Pro (56,6 %) sind konkurrenzfähig. Für automatisierte Code-Review- und Repair-Pipelines empfiehlt sich ein Benchmark gegen Ihr aktuelles Setup.
Terminal-Automatisierung: Führend bei Terminal-Bench 2.0, optimal für Shell-intensive Workflows, Dateioperationen, Prozessmanagement, Build-Pipelines.
MCP-Tool-Aufruf: MCPMark 48,2 % – Best-in-Class für MCP-basierte Integrationen.
Dokumentenanalyse mit langem Kontext: 1M Token-Fenster mit starken LongBench v2-Ergebnissen, geeignet für große Codebases und Spezifikationsdokumente.
Frontend-Code-Generierung: QwenWebBench (Elo-Rating: 1501,7 vs. 1517,9 für Claude Opus 4.5), praktisch gleichauf in der Frontend-Generierung.
Mehrsprachigkeit: WMT24++ 84,3 %, MAXIFE 88,2 % (23 Sprachen) – stark für nicht-englische Anwendungen.

Testen von Qwen3.6-Plus API-Aufrufen mit Apidog

Der Endpunkt ist OpenAI-kompatibel und lässt sich direkt in Apidog importieren und testen.

Richten Sie eine POST-Anfrage an https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions ein. Den API-Key setzen Sie als Umgebungsvariable: Authorization: Bearer {{DASHSCOPE_API_KEY}}.

Beispiel-Assertions für die Antwort-Validierung:

pm.test("Response contains choices", () => {
    const body = pm.response.json();
    pm.expect(body).to.have.property("choices");
    pm.expect(body.choices[0].message.content).to.be.a("string").and.not.empty;
});

pm.test("No empty reasoning when thinking enabled", () => {
    const choice = pm.response.json().choices[0];
    if (choice.message.reasoning_content !== undefined) {
        pm.expect(choice.message.reasoning_content).to.not.be.empty;
    }
});

Verwenden Sie Apidogs Smart Mock, um Testantworten während der Entwicklung zu generieren. So testen Sie Ihren Agenten-Code, ohne ständig die Live-API zu belasten – spart Tokens und beschleunigt die Testzyklen.

Für Multi-Turn-Agenten: Erstellen Sie ein Testszenario in Apidog, das mehrere Requests verknüpft. Überprüfen Sie, ob preserve_thinking die Argumentation über mehrere Züge hinweg beibehält, indem Sie bei jedem Schritt die Antwortstruktur validieren, bevor Sie das System in Produktion nehmen.

Apidog kostenlos herunterladen, um diese Tests direkt einzurichten.

Was kommt als Nächstes

Das Qwen-Team liefert Open-Source-Varianten in Kürze aus – nach Qwen3.5-Muster als spärliche MoE-Modelle mit Apache 2.0 Lizenzen.

Die Roadmap umfasst:

Noch komplexere Aufgaben auf Repository-Ebene und Dateiproblemlösung
Weitere Entwicklung multimodaler Agenten (GUI-Agenten, visuelles Coding als Kernfunktionalität)

Die Open-Source-Varianten von Qwen3.5 wurden schnell zu Standardmodellen für selbst gehostete Coding-Agenten. Das gleiche wird für Qwen3.6-Varianten erwartet.

Fazit

Qwen3.6-Plus schließt zu Claude Opus 4.5 bei Coding-Aufgaben auf und führt bei Terminal-Operationen, MCP-Tool-Aufrufen und langfristiger Planung. Das 1M Token-Kontextfenster, Anthropic-Kompatibilität und preserve_thinking für Agenten-Loops machen es für produktive Agentensysteme attraktiv.

Die kostenlose Vorschau auf OpenRouter war hilfreich zum Testen, die offizielle API bringt Stabilität, SLA und agentenoptimierte Features für zuverlässige Workflows.

Apidog übernimmt den Testpart: OpenAI-kompatiblen Endpunkt importieren, Assertions schreiben, Entwicklung simulieren und Regressionstests durchführen, wann immer Sie Modell oder API-Version aktualisieren.

FAQ

Was ist der Unterschied zwischen Qwen3.6-Plus und der Vorschau?

Die Vorschau (qwen/qwen3.6-plus-preview) startete am 30. März 2026 auf OpenRouter. Die offizielle Version bringt preserve_thinking, SLA-Betriebszeit und Model Studio-Unterstützung. Open-Source-Varianten folgen.

Was ist preserve_thinking und wann sollte ich es verwenden?

Standardmäßig wird nur die Argumentation des aktuellen Zuges beibehalten. Mit preserve_thinking: true bleibt die Chain-of-Thought aus allen bisherigen Zügen erhalten. Für mehrstufige Agenten-Loops nutzen.

Wie verhält sich Qwen3.6-Plus im Vergleich zu Claude Opus 4.5?

Claude Opus 4.5 liegt bei SWE-bench Verified (80,9 % vs. 78,8 %) und OSWorld-Verified (66,3 % vs. 62,5 %) vorn. Qwen3.6-Plus führt bei Terminal-Bench 2.0 (61,6 % vs. 59,3 %), MCPMark (48,2 % vs. 42,3 %), DeepPlanning (41,5 % vs. 33,9 %) und GPQA (90,4 % vs. 87,0 %).

Kann ich Qwen3.6-Plus mit Claude Code verwenden?

Ja. Setzen Sie ANTHROPIC_BASE_URL auf den Dashscope Anthropic-kompatiblen Endpunkt, ANTHROPIC_MODEL auf qwen3.6-plus, ANTHROPIC_AUTH_TOKEN auf Ihren Dashscope API-Key.

Ist Qwen3.6-Plus Open Source?

Das gehostete API-Modell ist nicht Open-Weight. Kleinere Varianten mit öffentlichen Gewichten erscheinen in Kürze.

Wie erhalte ich kostenlosen Zugang?

Installieren Sie Qwen Code (npm install -g @qwen-code/qwen-code@latest), starten Sie qwen, dann /auth. Nach OAuth erhalten Sie 1.000 kostenlose API-Aufrufe/Tag.

Welches Kontextfenster unterstützt es?

Standardmäßig 1M Tokens. Einige Benchmarks nutzten 256K für den Vergleich, aber der API-Standard ist 1M.

Wie teste ich die API-Integration vor der Bereitstellung?

Endpunkt in Apidog importieren, API-Key als Variable, Assertions schreiben, Entwicklung simulieren und Regressionstests beim Modell-/API-Update durchführen.

Holo3: Das beste Computernutzungsmodell?

Emre Demir — Thu, 02 Apr 2026 08:55:35 +0000

TL;DR

H Company hat Holo3 am 31. März 2026 veröffentlicht – ein Mixture-of-Experts-Modell, das auf OSWorld-Verified 78,85 % erreicht. Damit setzt es einen neuen Benchmark für KI-gestützte Desktop-Computernutzung und schlägt GPT-5.4 sowie Opus 4.6 zu deutlich geringeren Kosten. Die API ist ab sofort verfügbar, die 35B-Variante gibt es Open-Weight auf HuggingFace unter Apache 2.0.

Teste Apidog noch heute

Die Lücke bei der Computernutzung, die die meisten Entwickler noch nicht geschlossen haben

API-Automatisierung und CI/CD laufen stabil – aber viele Workflows brechen an einer Hürde: Alte Unternehmenssoftware ohne API, Desktop-Programme vor REST, mehrstufige Prozesse über mehrere GUIs.

Klassische RPA-Tools (z.B. UiPath) lösen das mit fragilen Koordinaten-Skripten – wartungsintensiv und fehleranfällig. Oft bleibt nur manuelle Arbeit.

KI-basierte Computernutzung bricht diese Grenze auf: Modelle, die Screenshots interpretieren und Aktionen (Klicks, Tippen, Scrollen) ausführen, können jede GUI automatisieren – ganz ohne API. Holo3, veröffentlicht von H Company, ist aktuell das leistungsfähigste öffentlich verfügbare Modell für diese Aufgabenklasse.

💡 Tipp: Wenn du Automatisierungs-Workflows oder Test-Pipelines für Desktop-Software entwickelst, solltest du die Holo3-API kennen. Die nächsten Abschnitte zeigen, wie du Holo3-Aufrufe in deinen Workflow integrierst – inklusive Test und Mocking mit Apidog.

Was ist Holo3?

Holo3 ist ein KI-Modell für Computernutzung: Du gibst einen Screenshot und eine Aufgabenbeschreibung, das Modell liefert die dafür notwendigen Aktionen (z.B. Klick, Tastendruck, Scrollen) zurück. Nach jeder Aktion erfasst du erneut einen Screenshot und wiederholst den Zyklus, bis die Aufgabe abgeschlossen ist.

Varianten von Holo3:

Holo3-122B-A10B: 122 Milliarden Parameter, 10 Milliarden aktiv (MoE). Nur als gehostete API verfügbar (hcompany.ai/holo-models-api). Setzt den Benchmark-Rekord.
Holo3-35B-A3B: 35 Milliarden Parameter, 3 Milliarden aktiv. Open-Weight auf HuggingFace (Apache 2.0), kostenlose API-Stufe, selbst hostbar.

MoE-Architektur: Nur ein Bruchteil der Parameter wird pro Token aktiviert – günstiger im Betrieb als die Parameterzahl erwarten lässt. H Company gibt an: Holo3-122B-A10B kostet pro Aufgabe weniger als GPT-5.4 und Opus 4.6.

OSWorld-Verified: Was der Benchmark misst

OSWorld-Verified ist der führende Benchmark für KI-Computernutzung. Im Unterschied zu klassischen Textbenchmarks prüft OSWorld echte Aufgaben auf echten Desktops – Erfolg wird durch den tatsächlichen Systemzustand nach Ausführung verifiziert.

Beispiele für Aufgaben:

Einzel-App: Datei öffnen, Formular ausfüllen, Daten kopieren
App-übergreifend: PDF auslesen, Tabelle updaten, E-Mail versenden
Multi-App-Sequenzen mit Kontext über mehrere Programme

Ergebnisse:

Holo3-122B-A10B erreicht 78,85 % – bisher waren >40 % Stand der Technik, führende Modelle von Anthropic/OpenAI lagen bei 60-65 %.

Gerade bei schwierigen, mehrstufigen Multi-App-Tasks liegt Holo3 deutlich vorne.

Wie Holo3 trainiert wurde: Agentic Learning Flywheel

Statt statischer Demos nutzt H Company eine kontinuierliche Pipeline:

Synthetische Navigationsdaten: Menschliche plus generierte Anweisungen erzeugen Szenarien.
Out-of-Domain-Erweiterung: Automatische Szenario-Varianten für Grenzfälle.
Kuratiertes Reinforcement Learning: Filterung & RL-Maximierung der Task-Completion-Raten.

Datenursprung: Die Synthetic Environment Factory erzeugt komplette Unternehmens-Apps samt verifizierbarer Aufgaben und End-to-End-Validierung. Das Modell trainiert an realistischen Business-Workflows.

Resultat: Holo3 schlägt größere Basismodelle (z.B. Qwen3.5) – nicht wegen Architektur, sondern Trainingsmethode.

So rufst du die Holo3 API auf

Die API nutzt einen Screenshot-Action-Loop. So gehst du vor:

1. Authentifizierung einrichten

# H Company Inference API base URL
https://api.hcompany.ai/v1

# Header
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

API-Key unter hcompany.ai/holo-models-api abrufen. Die kostenlose Stufe deckt Holo3-35B-A3B ab.

2. Screenshot mit Task senden

import base64
import httpx

# Screenshot aufnehmen (z.B. mit pyautogui)
import pyautogui
screenshot = pyautogui.screenshot()
screenshot.save("/tmp/screen.png")

with open("/tmp/screen.png", "rb") as f:
    image_b64 = base64.b64encode(f.read()).decode()

response = httpx.post(
    "https://api.hcompany.ai/v1/computer-use",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "model": "holo3-122b-a10b",
        "task": "Open the invoice folder and find the most recent PDF",
        "screenshot": image_b64,
        "screen_width": 1920,
        "screen_height": 1080
    }
)

action = response.json()
print(action)

3. Aktion parsen & ausführen

Die API gibt strukturierte Aktionen zurück:

{
  "action_type": "click",
  "coordinate": [245, 380],
  "reasoning": "The invoice folder icon is visible at this position"
}

Aktionstypen: click, double_click, right_click, type, key, scroll, screenshot_request, task_complete.

4. Schleife bis zur Fertigstellung

def run_computer_use_task(task: str, max_steps: int = 20):
    for step in range(max_steps):
        screenshot = capture_screen()
        response = call_holo3_api(task, screenshot)
        action = response["action"]

        if action["action_type"] == "task_complete":
            print(f"Done in {step + 1} steps")
            return response["result"]

        execute_action(action)

    raise TimeoutError("Task not completed within step limit")

Holo3 API-Aufrufe mit Apidog testen

Für produktionsreife Automatisierung ist zuverlässiges Testing Pflicht. Apidog unterstützt dich dabei:

Endpunkt importieren:

Lege in Apidog eine HTTP-Anfrage zu https://api.hcompany.ai/v1/computer-use an. Den Authorization-Header als Umgebungsvariable speichern.

Antwortvalidierung:

Mit Apidogs Test-Assertions prüfst du die API-Struktur:

// In Apidog's post-response script
pm.test("Action type is valid", () => {
    const validActions = ["click", "type", "key", "scroll", "task_complete", "screenshot_request"];
    pm.expect(validActions).to.include(pm.response.json().action.action_type);
});

pm.test("Coordinates are within screen bounds", () => {
    const action = pm.response.json().action;
    if (action.coordinate) {
        pm.expect(action.coordinate[0]).to.be.within(0, 1920);
        pm.expect(action.coordinate[1]).to.be.within(0, 1080);
    }
});

Mocking der API:

Mit Apidogs Smart Mock erzeugst du realistische Holo3-Antworten, ohne die Live-API zu belasten. Das spart Credits im Integrationstest und ermöglicht parallele Frontend-Entwicklung.

Testszenarien:

Verkette mehrere Holo3-Anfragen in Apidog, um Multistep-Workflows zu simulieren und die Aktionssequenz vor dem Live-Deployment zu prüfen.

Holo3 vs. Claude Computer Use vs. OpenAI Operator

	Holo3-122B	Holo3-35B	Claude Computer Use	OpenAI Operator
OSWorld-Verified	78.85%	~55%	~65%	~62%
API-Zugriff	Ja	Ja (free)	Ja	Ja
Offene Gewichte	Nein	Ja (Apache 2.0)	Nein	Nein
Selbst hostbar	Nein	Ja	Nein	Nein
Kosten vs. GPT-5.4	Niedriger	Viel niedriger	Vergleichbar	GPT-5.4 Preis
Am besten für	Produktion	Entwicklung/OSS	Anthropic-Stack	OpenAI-Stack

Empfehlung nach Use-Case:

Holo3-122B: Beste Genauigkeit, ideal für produktive Multi-App-Workflows.
Holo3-35B: Entwicklung, Test, Open Source, Self-Hosting.
Claude Computer Use: Für Anthropic-Nutzer mit einheitlicher Abrechnung.
OpenAI Operator: Für GPT-5.4-Nutzer, die einen Anbieter bevorzugen.

Unternehmens-Anwendungsfälle

Holo3 ist optimal für Workflows ohne saubere API:

Dateneingabe in Altsystemen: ERP/CRM ohne REST-API – Holo3 automatisiert die GUI, keine Modernisierung nötig.
Plattformübergreifender Abgleich: Zahlen aus PDF extrahieren, mit Tabelle abgleichen, Dashboard updaten – Holo3 übernimmt den kompletten Ablauf.
Regressionstests für Web-Apps: Statt fragiler Selenium-Skripte nutze Holo3 mit Klartext-Tasks – UI-Änderungen ohne Selektor-Pflege.
Wettbewerbsanalyse: Systematisches Scraping und Strukturdatenerfassung auf Webseiten, die Standard-Scraping blocken.

Benchmarks: Holo3 ist in allen vier Kategorien führend, vor allem bei Multi-App-Workflows mit komplexem Kontextmanagement.

Ausblick: Adaptive Agentur

H Company arbeitet am nächsten Schritt: Adaptive Agentur. Ziel ist ein Modell, das neue, maßgeschneiderte Unternehmenssoftware in Echtzeit versteht und navigiert – ohne vorherige Trainingsdaten. Der Agent baut sich beim Erstkontakt ein mentales Modell der UI-Struktur und erledigt Aufgaben adaptiv.

Das würde die größte Restriktion heutiger Computernutzungs-KI für Unternehmen beseitigen.

Fazit

Holo3 setzt mit 78,85 % auf OSWorld-Verified einen neuen Maßstab für Desktop-Automatisierung und schlägt Claude und GPT-basierte Lösungen bei komplexen Multi-App-Aufgaben. Die Open-Weight-Variante Holo3-35B-A3B unter Apache 2.0 macht einen kostenfreien Einstieg möglich.

Implementierungsmuster: Screenshot aufnehmen, API-POST, Aktion ausführen, wiederholen.

Testing: Mit Apidog validierst, mockst und testest du die Integration zuverlässig – bevor du live gehst.

Tipp: Entwickelst du etwas mit Desktop-GUI? Nutze Apidog kostenlos, um deine Holo3-Integration abzusichern.

Häufig gestellte Fragen

Was ist Holo3?

Holo3 ist ein KI-Modell von H Company für Computernutzung. Es verarbeitet Screenshots und gibt Aktionen (Klicks, Tastatur, Scrollen) für Desktop- oder Browser-Aufgaben zurück. Es erreicht 78,85 % auf dem OSWorld-Verified-Benchmark.

Ist Holo3 Open Source?

Die Variante Holo3-35B-A3B ist Open-Weight unter Apache 2.0 (Download auf HuggingFace). Holo3-122B-A10B ist nur per API nutzbar. Beide Varianten sind über die Inference API von H Company erhältlich, das 35B-Modell sogar kostenlos.

Wie funktioniert der OSWorld-Benchmark?

OSWorld testet echte Computeraufgaben (Web, Dateisystem, Multi-App). Der Erfolg wird über den Systemzustand nach Ausführung gemessen – nicht durch Ausgabetext. Die Aufgaben reichen von Einzel-App bis zu komplexen Multi-App-Workflows.

Wie schneidet Holo3 gegenüber Claude Computer Use ab?

Holo3-122B erzielt höhere Werte (78,85 % vs. ca. 65 % für Claude) und ist günstiger pro Aufgabe. Claude bleibt sinnvoll, wenn du bereits im Anthropic-Ökosystem bist.

Kann ich Holo3 lokal ausführen?

Ja, mit Holo3-35B-A3B (Open-Weight auf HuggingFace). Das 122B-Modell ist exklusiv per API.

Für welche Anwendungsfälle eignen sich Computernutzungs-APIs?

Automatisierung von Altsystemen (ohne REST-API), App-übergreifende Daten-Workflows, Regressionstests ohne fragile Selektoren, Scraping für Wettbewerbsanalysen – und generell alle manuellen Desktop-Workflows.

Wie teste ich meine Holo3 API-Integration?

Mit Apidog: Endpunkt importieren, Antwort-Assertions konfigurieren, die API mocken und Testszenarien für die Integration verketten.

Was ist „Adaptive Agentur“ in der Holo3 Roadmap?

Zukünftige Modelle sollen neue, unbekannte Unternehmenssoftware in Echtzeit navigieren können – durch UI-Strukturerkennung ohne vorherige Trainingsdaten. Das würde KI-gestützte Computernutzung auch für individuell entwickelte Unternehmenslösungen universell machen.

axios@1.14.1 Supply Chain Attacke: Was jetzt zu tun ist

Emre Demir — Thu, 02 Apr 2026 08:50:35 +0000

Kurz gesagt

Am 30.–31. März 2026 wurden die axios-Versionen 1.14.1 und 0.30.4 auf npm mit einer bösartigen Abhängigkeit kompromittiert, die einen Remote Access Trojaner (RAT) auf infizierten Maschinen platziert. Beide Versionen wurden von der Veröffentlichung zurückgezogen. Die sichere Version ist 1.14.0. Wenn Sie axios@1.14.1 oder 0.30.4 installiert haben, behandeln Sie die Maschine als kompromittiert und ändern Sie sofort alle Zugangsdaten.

Apidog jetzt ausprobieren

Was axios ist und warum dies wichtig ist

axios hat wöchentlich 100 Millionen Downloads auf npm. Es ist der HTTP-Client in unzähligen Frontend-Frameworks, Backend-Node.js-Diensten und Unternehmensanwendungen. Wird ein so grundlegendes Paket kompromittiert, sind die Auswirkungen gravierend – Entwickler, die im Zeitfenster 30.–31. März npm install ausgeführt haben, haben unwissentlich Malware installiert.

Das ist kein theoretisches Risiko. Es ist passiert, bestätigt und die Nutzlast war ernst: Ein mehrstufiger Remote Access Trojaner, der beliebige Befehle ausführen, Systemdaten exfiltrieren und persistieren kann.

Wenn Ihr Team axios nutzt und Sie Apidog zum Testen Ihrer HTTP-Integrationen einsetzen, lesen Sie weiter, bevor Sie deployen.

Chronologie des Angriffs

30. März 2026 — 23:59:12 UTC:

Ein bösartiges Paket namens plain-crypto-js@4.2.1 wird von nrwise@proton.me auf npm veröffentlicht. Eine saubere Version (4.2.0) wurde 18 Stunden zuvor als Typosquatting der legitimen crypto-js-Bibliothek veröffentlicht.

31. März 2026 — 00:05:41 UTC:

Die automatisierte Malware-Erkennung von Socket meldet plain-crypto-js@4.2.1 als bösartig – sechs Minuten nach Veröffentlichung.

31. März 2026 — kurz nach Mitternacht:

axios@1.14.1 erscheint auf npm und zieht plain-crypto-js@4.2.1 als Abhängigkeit ein. Dieser Release erscheint nicht in den offiziellen Tags des axios GitHub-Repositorys. Der neueste legitime Tag bleibt v1.14.0.

31. März 2026 — Vormittag:

Das GitHub-Issue #10604 meldet axios@1.14.1 und axios@0.30.4 als kompromittiert. Die axios-Betreuer bestätigen, dass sie den Angreiferzugriff zunächst nicht entfernen können – das kompromittierte Konto hatte höhere npm-Berechtigungen.

31. März 2026:

Beide Versionen werden von npm zurückgezogen. Die axios-Betreuer widerrufen Tokens, verschärfen Release-Kontrollen und untersuchen, wie ein langlebiges npm-Token missbraucht wurde.

Wie der Angriff funktionierte

Der Angriff nutzte ein langlebiges npm-Token im Release-Workflow aus. Nach der Kompromittierung eines Betreuer-Zugangs veröffentlichte der Angreifer eine neue Version außerhalb des üblichen Release-Prozesses.

Die neue Version zog plain-crypto-js@4.2.1 als Abhängigkeit hinzu. Der Paketname sollte wie ein legitimes Kryptographie-Utility wirken; die saubere Version 4.2.0 schuf Historie, um Verdacht zu mindern.

Socket identifizierte folgende Angriffsstufen in plain-crypto-js@4.2.1:

Stufe 1 — Ausführung: Beim Installieren wird Code via npm-Lifecycle-Skripte ausgeführt, der eine zweite Nutzlast ablegt.
Stufe 2 — RAT-Bereitstellung: Installation eines Remote Access Trojaners, der eine persistente Hintertür öffnet.
Stufe 3 — Exfiltration: Der RAT kann Shell-Befehle ausführen, Umgebungsvariablen und Secrets lesen und Systemdaten exfiltrieren.

Der RAT bleibt über Neustarts persistiert. Maschinen, die die kompromittierte Version installiert haben, sind weiter gefährdet, selbst nach Entfernen des npm-Pakets, solange der RAT nicht gezielt entfernt wird.

Bin ich betroffen?

Sie sind betroffen, wenn:

Sie zwischen 30. März, 23:59 UTC und 31. März 2026, mittags UTC ein npm install axios oder npm install (mit axios in package.json) ausgeführt haben.
Ihre Datei node_modules/axios/package.json die Version 1.14.1 oder 0.30.4 anzeigt.
Ihre package-lock.json oder yarn.lock axios auf 1.14.1 oder 0.30.4 auflöst.

Checkliste zum Überprüfen:

# Installierte Version prüfen
npm list axios

# Lock-Datei prüfen
grep '"axios"' package-lock.json | head -5

# Nach plain-crypto-js suchen
npm list plain-crypto-js
ls node_modules/plain-crypto-js 2>/dev/null && echo "INFIZIERT" || echo "Nicht gefunden"

Wenn plain-crypto-js in Ihren node_modules liegt, wurde die bösartige Version ausgeführt.

Was jetzt zu tun ist

1. axios sofort aktualisieren

npm install axios@1.14.0
# oder auf die neueste sichere Version pinnen
npm install axios@latest

Verifizierung:

npm list axios
# Sollte 1.14.0 oder höher anzeigen (sobald ein bereinigtes 1.14.x verfügbar ist)

2. Wenn Sie die kompromittierte Version installiert haben

Behandeln Sie dies als vollständigen Sicherheitsvorfall:

Alle Zugangsdaten (Secrets) ändern: API-Schlüssel, Datenbank-Credentials, SSH-Keys, Cloud-Provider-Tokens, .env-Dateien.
Umgebungsvariablen prüfen: Der RAT exfiltriert gezielt Secrets aus Umgebungsvariablen und Filesystem.
Ausgehende Netzwerkverbindungen prüfen: Suchen Sie im fraglichen Zeitraum nach Verbindungen zu unbekannten IPs.
Persistenzmechanismen suchen: Cronjobs, Startskripte und systemd-Dienste auf neue Einträge im Kompromittierungszeitraum überprüfen.
Maschine neu aufsetzen: Bei CI-Runnern oder Produktionssystemen unbedingt ein Re-Imaging durchführen. Bei Entwickler-Laptops: Secrets kompromittiert betrachten und alles ändern, bevor die Maschine weiterverwendet wird.

3. CI/CD-Pipelines prüfen

Wenn Ihre Build-Pipeline im betroffenen Zeitraum npm install ausgeführt hat, ist Ihre CI-Umgebung potenziell betroffen.

# Build-Logs im betroffenen Zeitraum prüfen
# Nach axios@1.14.1 im Install-Output suchen

# Aktuelle CI node_modules prüfen
npm list axios plain-crypto-js

Alle Secrets ändern, auf die die CI-Pipeline Zugriff hat: Deploy-Keys, Cloud-Zugangsdaten, Registry-Tokens.

4. Lock-Datei prüfen

Lock-Dateien (package-lock.json, yarn.lock) sollten keine kompromittierten Versionen enthalten. Falls doch, Datei löschen und neu generieren:

# Lock-Datei entfernen und neu erstellen
rm package-lock.json
npm install

Vor dem Commit sicherstellen, dass die neue Lock-Datei axios auf eine sichere Version auflöst.

Apidog zur Überprüfung Ihrer axios API-Aufrufe verwenden

Setzen Sie axios als HTTP-Client ein, kann Apidog Sie bei der Prüfung unterstützen, ob Ihre Integration nach dem Update weiterhin korrekt funktioniert.

Vorgehen:

Nach Update auf axios@1.14.0 Ihre API-Endpunkte in Apidog importieren.
Regressionstests durchführen, um Änderungen im Verhalten auszuschließen.
Mit den Assertion-Features von Apidog prüfen, ob keine Payloads oder Header manipuliert wurden:

// Apidog Post-Response Assertion
pm.test("Response is clean — no injected fields", () => {
    const body = pm.response.json();
    pm.expect(body).to.not.have.property('__injected');
    pm.expect(pm.response.headers.get('X-Injected-Header')).to.be.null;
});

Führen Sie Ihre komplette Testsuite gegen die bereinigte axios-Version in Apidog aus und dokumentieren Sie das Ausgangsverhalten vor dem Produktions-Rollout.

Apidog kostenlos testen, um HTTP-Client-Regressionstests einzurichten.

Warum Lieferkettenangriffe auf npm schwer zu stoppen sind

Der axios-Angriff ist kein Einzelfall. Das Muster wiederholt sich:

event-stream (2018): Nutzlast zur Bitcoin-Wallet-Exfiltration. 8 Mio. Downloads/Woche.
ua-parser-js (2021): Kompromittierung zur Installation von Cryptominern und Passwortdieben.
node-ipc (2022): Maintainer fügt destruktiven Code gegen russische/weißrussische IPs ein.
xz utils (2024): Zwei Jahre Social Engineering für die Hintertür einer zentralen Linux-Bibliothek.
axios (2026): Kompromittierte Betreuer-Zugänge für RAT-Release über Abhängigkeit.

Zentral:

Das Vertrauen gilt dem veröffentlichenden Konto, nicht dem Code. Werden Maintainer-Zugangsdaten kompromittiert, erbt der Angreifer sofort das Release-Vertrauen.

Empfohlene Maßnahmen:

Maßnahme	Wirkung
Lock-Dateien (`package-lock.json`)	Fixiert exakte Versionen, verhindert stille Upgrades
`npm audit` in CI	Meldet bekannte Schwachstellen vor Deployment
Socket.dev / Snyk	Verhaltensanalyse – erkennt verdächtige Pakete früh
Zwei-Faktor-Authentifizierung auf npm	Erschwert Kompromittierung von Maintainer-Accounts
`npm publish` mit kurzlebigen Tokens	Begrenzt das Expositionsfenster bei Token-Leakage
Lock-Dateien in PRs prüfen	Unerwartete Abhängigkeitsänderungen im Review erkennen

Das axios-Team verschärft die Release-Kontrollen und setzt auf kurzlebige Tokens. Die nachhaltige Lösung muss jedoch vom gesamten Ökosystem ausgehen.

Indikatoren einer Kompromittierung (IOCs)

Basierend auf der Analyse von Socket:

Bösartige Pakete: plain-crypto-js@4.2.1, axios@1.14.1, axios@0.30.4
E-Mail des Herausgebers: nrwise@proton.me
Verhalten: Netzwerkverbindungen bei npm-Installation, RAT-Persistenz, Exfiltration von Secrets
Sichere axios-Versionen: 1.14.0 und älter (außer 0.30.4), 1.13.x, 1.12.x

Bei Infektionsverdacht: Bericht an npm security (security@npmjs.com) senden und Logs sichern.

Fazit

Die axios-Komprimittierung zeigt: Abhängigkeits-Sicherheit ist ein fortlaufender Prozess. Versionen pinnen, Tools wie Socket in CI, Zugangsdaten bei Auffälligkeiten ändern, Lock-Dateien im Review prüfen.

Möchten Sie nach einem axios-Update Ihre API-Integration validieren, bietet Ihnen Apidog Assertions, Mocking und Regressionstests, um Ihren HTTP-Client abzusichern, bevor Sie releasen.

Häufig gestellte Fragen (FAQ)

Welche axios-Versionen sind kompromittiert?

axios@1.14.1 und axios@0.30.4. Beide wurden von npm zurückgezogen. Die sichere Version ist 1.14.0 (bzw. jede 1.13.x, 1.12.x).

Was bewirkt die bösartige axios-Nutzlast?

Sie zieht plain-crypto-js@4.2.1 ein, das einen mehrstufigen Remote Access Trojaner (RAT) bereitstellt. Dieser kann Befehle empfangen, Secrets exfiltrieren und persistieren.

Woher weiß ich, ob ich die kompromittierte Version installiert habe?

Führen Sie npm list axios aus – erscheint 1.14.1 oder 0.30.4, sind Sie betroffen. Prüfen Sie zusätzlich npm list plain-crypto-js – ist das Paket vorhanden, lief der bösartige Code.

Reicht ein Update auf eine saubere Version?

Nein. Das Update entfernt die Abhängigkeit für die Zukunft, aber der RAT könnte schon installiert und aktiv sein. Ändern Sie alle Secrets und prüfen Sie die Maschine auf Persistenzmechanismen.

Wie konnte der Angreifer auf npm veröffentlichen?

Wahrscheinlich durch kompromittierte Maintainer-Zugangsdaten und ein langlebiges npm-Token mit Release-Rechten. Das axios-Team zieht Konsequenzen und verschärft Release-Kontrollen.

Was ist der Unterschied zu einer regulären Schwachstelle?

Eine Schwachstelle ist ein Bug im legitimen Code. Ein Lieferkettenangriff bringt bösartigen Code über einen vertrauenswürdigen Release-Kanal ein – der Code war nie im axios-GitHub, sondern wurde direkt ins npm-Paket injiziert.

Wie kann ich meine Projekte vor Lieferkettenangriffen schützen?

Lock-Dateien nutzen, npm audit in CI, Socket.dev oder ähnliche Tools für Verhaltensanalyse, 2FA für npm-Konten, kurzlebige Publish-Tokens und Lockfile-Diffs im Code-Review überprüfen.