> ## Documentation Index
> Fetch the complete documentation index at: https://docs.aihubmix.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Videoverständnis

> Rufen Sie Qwen3.7 Plus über die Chat Completions- und Responses-APIs von AIHubMix mit öffentlichen oder lokalen MP4-Videos auf und erhalten Sie Szenenbeschreibungen, Zeitstempel und JSON-Ergebnisse.

<h2 id="overview">
  Überblick
</h2>

Beim Videoverständnis analysiert das Modell Videobilder anhand von Textanweisungen und gibt Beschreibungen, Zeitstempel oder strukturierte Ergebnisse zurück. Typische Anwendungen sind:

* Beschreibung von Szenen und Handlungen von Personen
* Videozusammenfassungen und Fragen zum Inhalt
* Ermittlung von Anfang und Ende eines Ereignisses
* Extraktion von Informationen im JSON-Format

Dieser Leitfaden zeigt anhand von `qwen3.7-plus`, wie Sie MP4-Videos mit Chat Completions und der Responses API übergeben.

<h2 id="protocols">
  APIs und Eingabeformate
</h2>

| Modell und Endpunkt | Feld für Videoinhalte | Parameter für JSON-Ausgabe |
| - | - | - |
| `qwen3.7-plus`, `/v1/chat/completions` | `video_url` in `messages[].content[]` | `response_format.type = "json_object"` |
| `qwen3.7-plus`, `/v1/responses` | `video_url` in `input[].content[]` | `text.format.type = "json_object"` |

In Responses ist `video_url` ein Erweiterungsfeld von AIHubMix. Die folgenden Beispiele übergeben es per HTTP-Anfrage.

Multimedia-Eingaben für Gemini-Modelle werden im [Gemini-Leitfaden](/de/api/Gemini-Guides) beschrieben.

<h2 id="chat-url">
  Schnellstart
</h2>

Das folgende Beispiel verwendet das integrierte `fetch` von Node.js 22. Eine SDK-Installation ist nicht erforderlich. Setzen Sie vor der Ausführung `AIHUBMIX_API_KEY` in Ihrer Umgebung. Die Beispiel-URL verweist auf eine öffentliche MP4-Datei aus der offiziellen Dokumentation von Alibaba. Ersetzen Sie `url` für Ihre Anwendung durch eine Videoadresse, auf die der Modellanbieter zugreifen kann.

<CodeGroup>
  ```javascript Chat: Öffentliche MP4 theme={null}
  const response = await fetch("https://aihubmix.com/v1/chat/completions", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.AIHUBMIX_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "qwen3.7-plus",
      enable_thinking: false,
      max_tokens: 800,
      response_format: { type: "json_object" },
      messages: [{
        role: "user",
        content: [
          {
            type: "video_url",
            video_url: {
              url: "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241115/cqqkru/1.mp4",
            },
          },
          {
            type: "text",
            text: 'Analyze the attached video. Return a JSON object with a scenes array. Each scene must contain start_seconds, end_seconds and description. If no video is available, return {"error":"no_video"}.',
          },
        ],
      }],
    }),
    signal: AbortSignal.timeout(120000),
  });
  const result = await response.json();
  if (!response.ok) throw new Error(JSON.stringify(result));
  const scenes = JSON.parse(result.choices[0].message.content);
  console.log(JSON.stringify({
    request_id: response.headers.get("x-aihubmix-request-id"),
    result: scenes,
    usage: result.usage,
  }, null, 2));
  ```
</CodeGroup>

Speichern Sie den Code als `.mjs`-Datei und führen Sie ihn mit Node.js aus. Das erfolgreiche Ergebnis steht in `choices[0].message.content` und muss erneut als JSON geparst werden. Das Beispiel gibt auch die Anfrage-ID und den Verbrauch zum Abgleich in der Konsole aus.

<h2 id="chat-base64">
  Lokale Videoeingabe
</h2>

Kodieren Sie die lokale Datei als Base64 und übergeben Sie sie als Daten-URL mit `data:video/mp4;base64,`. Das Beispiel liest den Dateipfad aus dem ersten Befehlszeilenargument oder, wenn keines angegeben wurde, `video.mp4` aus dem aktuellen Verzeichnis. Die Video-URL in einer HTTP-Anfrage kann kein lokaler Dateipfad sein.

<CodeGroup>
  ```javascript Chat: Lokale MP4 theme={null}
  import { readFileSync } from "node:fs";

  const video = readFileSync(process.argv[2] ?? "video.mp4").toString("base64");
  const response = await fetch("https://aihubmix.com/v1/chat/completions", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.AIHUBMIX_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "qwen3.7-plus",
      enable_thinking: false,
      max_tokens: 800,
      response_format: { type: "json_object" },
      messages: [{
        role: "user",
        content: [
          {
            type: "video_url",
            video_url: { url: `data:video/mp4;base64,${video}` },
          },
          {
            type: "text",
            text: 'Analyze the attached video. Return a JSON object with a scenes array. Each scene must contain start_seconds, end_seconds and description. If no video is available, return {"error":"no_video"}.',
          },
        ],
      }],
    }),
    signal: AbortSignal.timeout(120000),
  });
  const result = await response.json();
  if (!response.ok) throw new Error(JSON.stringify(result));
  const scenes = JSON.parse(result.choices[0].message.content);
  console.log(JSON.stringify({
    request_id: response.headers.get("x-aihubmix-request-id"),
    result: scenes,
    usage: result.usage,
  }, null, 2));
  ```
</CodeGroup>

<h2 id="responses">
  Responses API
</h2>

Responses-Anfragen verwenden ebenfalls das Objekt `video_url`, während Textblöcke `input_text` verwenden. Konfigurieren Sie die JSON-Ausgabe unter `text.format`. Auch dieses Beispiel liest das Video aus dem ersten Befehlszeilenargument oder aus `video.mp4` im aktuellen Verzeichnis.

<CodeGroup>
  ```javascript Responses: Lokale MP4 theme={null}
  import { readFileSync } from "node:fs";

  const video = readFileSync(process.argv[2] ?? "video.mp4").toString("base64");
  const response = await fetch("https://aihubmix.com/v1/responses", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.AIHUBMIX_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "qwen3.7-plus",
      max_output_tokens: 800,
      text: { format: { type: "json_object" } },
      input: [{
        role: "user",
        content: [
          {
            type: "video_url",
            video_url: { url: `data:video/mp4;base64,${video}` },
          },
          {
            type: "input_text",
            text: 'Analyze the attached video. Return a JSON object with a scenes array. Each scene must contain start_seconds, end_seconds and description. If no video is available, return {"error":"no_video"}.',
          },
        ],
      }],
    }),
    signal: AbortSignal.timeout(120000),
  });
  const result = await response.json();
  if (!response.ok || result.status !== "completed") {
    throw new Error(JSON.stringify(result));
  }
  const text = result.output
    .filter((item) => item.type === "message")
    .flatMap((item) => item.content)
    .filter((part) => part.type === "output_text")
    .map((part) => part.text)
    .join("");
  console.log(JSON.stringify({
    request_id: response.headers.get("x-aihubmix-request-id"),
    result: JSON.parse(text),
    usage: result.usage,
  }, null, 2));
  ```
</CodeGroup>

Das Feld `output` von Responses kann sowohl Reasoning- als auch Nachrichtenelemente enthalten. Wählen Sie zum Lesen des Ergebnisses `output_text` aus den `message`-Elementen aus. Der Ausgabeverbrauch kann Reasoning-Tokens enthalten. Die Länge des endgültigen JSON allein reicht daher nicht zur Kostenschätzung aus.

<h2 id="structured-output">
  Strukturierte Ausgabe
</h2>

Die Beispiele geben im JSON-Modus ein Array `scenes` zurück. Jede Szene enthält:

| Feld | Typ | Bedeutung |
| - | - | - |
| `start_seconds` | Zahl | Anfangszeit der Szene in Sekunden |
| `end_seconds` | Zahl | Endzeit der Szene in Sekunden |
| `description` | Zeichenfolge | Beschreibung des Szeneninhalts |

Passen Sie Prompt und Felder an Ihre Anwendung an. Der JSON-Modus stellt eine JSON-Ausgabe sicher. Feldtypen, Pflichtfelder und Zeitbereiche sollten von der Anwendung validiert werden.

<h2 id="limits">
  Datei- und Dauerlimits
</h2>

Die [offizielle Vision-Dokumentation von Alibaba](https://help.aliyun.com/zh/model-studio/vision) nennt folgende Videolimits für die Qwen3.7-Serie:

* Zu den Videoformaten gehören MP4, AVI, MKV, MOV, FLV und WMV.
* Die Videodauer liegt zwischen 2 Sekunden und 2 Stunden.
* Die Base64-kodierte Zeichenfolge muss kleiner als 10MB sein. Eine Originaldatei unter 7MB wird empfohlen.
* Bei öffentlichen URLs beträgt das Dateigrößenlimit des Anbieters 2GB.

Base64 vergrößert die Anfrage. Verwenden Sie für größere Dateien bevorzugt öffentliche Video-URLs und stellen Sie sicher, dass der Link während der gesamten Anfrage gültig bleibt.

<h2 id="billing">
  Abrechnung und Tokens
</h2>

Qwen wandelt Videobilder in Eingabetokens um, die zusammen mit dem Prompt zum Eingabeverbrauch zählen. Generierte Inhalte zählen zum Ausgabeverbrauch. Videodauer, Auflösung und Frame-Auswahl beeinflussen den Verbrauch. Die MP4-Dateigröße oder Dauer allein reicht nicht aus, um die Kosten zu berechnen.

Videoeingaben von Qwen3.7 Plus werden zum Eingabetokenpreis des Modells abgerechnet, generierte Inhalte zum Ausgabetokenpreis. Die Preise finden Sie auf der [Modellseite von Qwen3.7 Plus](https://aihubmix.com/model/qwen3.7-plus).

* Chat Completions meldet `usage.prompt_tokens` und `usage.completion_tokens`.
* Responses meldet `usage.input_tokens` und `usage.output_tokens`.
* Reasoning-Tokens sind bereits in den Ausgabetokens enthalten und dürfen nicht erneut addiert werden.
* Cache-Treffer werden zum jeweils geltenden Cache-Preis abgerechnet.

Tokenverbrauch und Kosten jeder Anfrage können Sie in der Konsole einsehen. Bewahren Sie zur Untersuchung einer bestimmten Anfrage den Antwortheader `x-aihubmix-request-id` auf.

<h2 id="usage-tips">
  Empfehlungen
</h2>

* Senden Sie Video und Textanweisungen gemeinsam und geben Sie die zu extrahierenden Informationen sowie das Ausgabeformat an.
* Öffentliche Videolinks müssen während der Anfrage gültig und für den Modellanbieter erreichbar bleiben.
* Verwenden Sie Base64 für kleine lokale Dateien und bevorzugen Sie öffentliche URLs für größere Dateien.
* Validieren Sie JSON-Felder, Szenenreihenfolge und Zeitbereiche in Ihrer Anwendung.
* Zeitstempel eignen sich zum Auffinden von Ereignissen und Inhalten. Für präzise Schnitte sollten Sie die Grenzen mit Videobearbeitungswerkzeugen abgleichen.

***

Aktualisiert: 2026-10-13


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.