MiniMax H3 API verwenden

MiniMax H3, auch als Hailuo 3 oder Hailuo 03 gesucht, ist das neueste Videogenerationsmodell von MiniMax. Es unterstützt drei unterschiedliche Arbeitsabläufe: Erstellen eines Videos aus Text, Animieren eines Start- oder Endbilds und Erstellen eines neuen Clips aus Bild-, Video- und Audioreferenzen.

Diese Anleitung zeigt, wie Sie über EvoLink auf MiniMax H3 zugreifen, die richtige Modell-ID auswählen, eine Anfrage senden, die asynchrone Aufgabe verfolgen und das fertige Video abrufen. Die Beispiele verwenden in allen drei Modi denselben einheitlichen Videoendpunkt, sodass Sie H3 zu einem vorhandenen Produktionsworkflow hinzufügen können, ohne ein separates Aufgabensystem aufzubauen.

Schnelle Antwort

• Endpunkt: POST https://api.evolink.ai/v1/videos/generations
• Authentifizierung: Bearer-API-Schlüssel
• Text-zu-Video-Modell: minimax-h3-text-to-video
• Bild-zu-Video-Modell: minimax-h3-image-to-video
• Referenzvideo-Modell: minimax-h3-reference-to-video
• Ausgabe: 2K-Video
• Dauer: 4–15 Sekunden
• Task-Ablauf: Anfrage senden, Task-ID erhalten und anschließend den Task-Endpunkt abfragen oder einen HTTPS-Callback verwenden
• Lebensdauer des Ergebnisses: Laden Sie fertige Videos innerhalb von 24 Stunden herunter und speichern Sie sie

Inhaltsverzeichnis

1. Was MiniMax H3 kann
2. Hauptfunktionen und praktische Upgrades
3. MiniMax H3 API auf einen Blick
4. So greifen Sie auf die MiniMax H3 API zu
5. Wählen Sie den richtigen Generierungsmodus
6. Schnellstart: Senden Sie Ihre erste Anfrage in 60 Sekunden
7. Verstehen Sie den asynchronen Workflow
8. Text-zu-Video-Beispiel
9. Bild-zu-Video-Beispiele
10. Referenz-Video-Beispiel
11. Lokale Medien hochladen
12. Vollständige TypeScript-Implementierung
13. Vollständige Python-Implementierung
14. Parameter- und Prompt-Übersicht
15. Häufige Fehler und Korrekturen
16. Preis- und Kostenplanung
17. Produktionscheckliste
18. Praktische Anwendungsfälle
19. FAQ

1. Was MiniMax H3 kann

MiniMax H3 ist für die Erstellung von Kurzvideos mit unterschiedlichen Ebenen der kreativen Kontrolle konzipiert. Die drei API-Modi haben denselben Aufgabenlebenszyklus, akzeptieren jedoch unterschiedliche Eingaben.

Der Hauptunterschied liegt in der Steuerbarkeit. Text-zu-Video gibt dem Modell die größte Freiheit. Bild-zu-Video verankert die Komposition in einem oder zwei Frames. Beim Referenzvideo können Sie beschreiben, wie mehrere Quellmedien das Ergebnis beeinflussen sollen.

2. Hauptfunktionen und praktische Upgrades

Die für Entwickler nützlichsten H3-Änderungen sind im Ein- und Ausgabevertrag sichtbar:

• Drei speziell entwickelte Workflows. Text, Keyframe und multimodale Referenzgenerierung haben separate Modell-IDs, verwenden aber einen EvoLink-Endpunkt.
• 2K-Ausgabe. Die aktuellen H3-Routen stellen eine einzelne 2k-Qualitätsoption bereit.
• Flexible 4–15-Sekunden-Clips. Die Dauer ist eine ganze Zahl, was es einfacher macht, die Generierungslänge an einen Aufnahmeplan anzupassen.
• Steuerung des ersten und letzten Bildes. Bild-zu-Video akzeptiert ein Startbild, ein Endbild oder beides.
• Umfangreichere Referenzeingaben. Referenzvideo akzeptiert geordnete Bild-, Video- und Audio-Arrays und ermöglicht so eine explizitere kreative Ausrichtung als ein einzelnes Motivbild.
• Produktionsorientierte Aufgabenbearbeitung. EvoLink bietet einen konsistenten asynchronen Aufgabenendpunkt und einen optionalen Abschlussrückruf in allen drei Modi.

Der letzte Punkt ist eine EvoLink-Integrationsfunktion, keine Modellfähigkeit. Dies ist wichtig, da eine Produktionsanwendung unabhängig vom ausgewählten Modell vorhersehbare Aufgabenzustände, Callbacks, Protokollierung und Ergebnisverarbeitung benötigt.

Wie sich dies von Hailuo 2.3 unterscheidet

Offizielles Beispiel: Video- und Sprachreferenz

3. MiniMax H3 API auf einen Blick

Alle drei Modi verwenden:

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

Gemeinsame Regeln:

• duration akzeptiert ganze Zahlen von 4 bis 15; Der Standardwert ist 5.
• quality muss 2k sein. Senden Sie nicht 768p.
• Prompts können auf Englisch oder Chinesisch verfasst werden.
• Halten Sie Prompts innerhalb von etwa 1.000 englischen Wörtern oder 500 chinesischen Schriftzeichen.
• Bitrate, Bildrate und Codec sind nicht konfigurierbar.
• Die Generierung erfolgt asynchron.

4. So greifen Sie auf die MiniMax H3-API zu

Sie benötigen ein EvoLink-Konto, einen API-Schlüssel und ausreichend Guthaben für die angeforderte Aufgabe.

1. Erstellen Sie Ihr EvoLink-Konto oder melden Sie sich an.
2. Öffnen Sie das API-Schlüssel-Dashboard und erstellen Sie einen Schlüssel.
3. Speichern Sie den Schlüssel in einer serverseitigen Umgebungsvariablen.
4. Wählen Sie den H3-Modus, der Ihren verfügbaren Eingängen entspricht.
5. Senden Sie eine Anfrage an den Unified Video-Endpunkt.

EVOLINK_API_KEY=your_api_key

Legen Sie diesen Schlüssel niemals in Browser-JavaScript, einem öffentlichen Repository oder einem mobilen Anwendungspaket offen. Rufen Sie die EvoLink-API von Ihrem Server, Ihrer Serveraktion, Ihrer API-Route, Ihrem Worker oder einer anderen vertrauenswürdigen Laufzeit aus auf.

5. Wählen Sie den richtigen Generierungsmodus

Verwenden Sie diese Routing-Tabelle, bevor Sie eine Nutzlast erstellen:

6. Schnellstart: Senden Sie Ihre erste Anfrage in 60 Sekunden

Schritt 1: Senden Sie eine Text-zu-Video-Anfrage

curl -X POST https://api.evolink.ai/v1/videos/generations \
  -H "Authorization: Bearer $EVOLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "minimax-h3-text-to-video",
    "prompt": "A compact electric concept car drives through a rain-soaked city at night. The camera tracks beside the car, then slowly pulls back to reveal neon reflections across the street.",
    "quality": "2k",
    "aspect_ratio": "16:9",
    "duration": 5
  }'

Die API gibt eine asynchrone Aufgabe zurück:

{
  "id": "task-unified-example",
  "status": "pending",
  "created": 1785470400
}

Schritt 2: Überprüfen Sie die Aufgabe

curl https://api.evolink.ai/v1/tasks/task-unified-example \
  -H "Authorization: Bearer $EVOLINK_API_KEY"

{
  "id": "task-unified-example",
  "status": "completed",
  "results": [
    "https://example-cdn.com/generated-video.mp4"
  ]
}

Laden Sie das Ergebnis innerhalb von 24 Stunden herunter. Kopieren Sie es in Ihren eigenen dauerhaften Speicher, falls Ihre Anwendung es später benötigt.

7. Verstehen Sie den asynchronen Workflow

Die Videogenerierung dauert länger als eine normale HTTP-Anfrage. Der Aufruf „create“ gibt daher eine Aufgabe zurück, anstatt die Verbindung offen zu halten, bis das Video fertig ist.

Submit request
      ↓
Receive task ID
      ↓
pending → processing
      ↓
completed or failed
      ↓
Download completed result

Der Aufgabenstatus kann sein:

• pending: Die Anforderung befindet sich in der Warteschlange.
• processing: Generierung läuft.
• completed: Das Array results enthält die Ausgabe.
• failed: Überprüfen Sie die Fehlerinformationen und entscheiden Sie, ob die Anfrage korrigiert oder erneut versucht werden soll.

Polling oder Callback?

• Verwenden Sie HTTPS.
• Darf nicht länger als 2.048 Zeichen sein.
• Auflösen zu einem öffentlichen Ziel, nicht zu einer privaten IP.
• Antworten Sie innerhalb von 10 Sekunden.
• Geben Sie eine 2xx-Antwort zurück, nachdem das Ereignis akzeptiert wurde.

Fehlgeschlagene Lieferungen werden dreimal mit Verzögerungen von etwa 1, 2 und 4 Sekunden wiederholt. Ihr Handler sollte sicher sein, wenn dasselbe Ereignis mehr als einmal empfangen wird.

8. Text-zu-Video-Beispiel

Text-to-Video akzeptiert einen Prompt ohne Medieneingabe.

{
  "model": "minimax-h3-text-to-video",
  "prompt": "A ceramic coffee cup sits on a wooden table beside a window. Morning steam curls upward while the camera makes a slow clockwise orbit. Natural light, realistic texture, quiet editorial mood.",
  "quality": "2k",
  "aspect_ratio": "4:3",
  "duration": 8,
  "callback_url": "https://api.example.com/webhooks/evolink"
}

Zu den unterstützten Seitenverhältnissen gehören:

• 21:9
• 16:9
• 4:3
• 1:1
• 3:4
• 9:16
• Adaptiv

9. Bild-zu-Video-Beispiele

Animieren Sie ein Startbild

{
  "model": "minimax-h3-image-to-video",
  "prompt": "The camera slowly moves closer as the fabric responds to a soft breeze. Preserve the product shape, label, and lighting.",
  "image_start": "https://assets.example.com/product-start.webp",
  "quality": "2k",
  "duration": 6
}

Generieren Sie in Richtung eines Endrahmens

{
  "model": "minimax-h3-image-to-video",
  "prompt": "A wide landscape shot gradually resolves into the supplied final frame, with continuous forward camera movement and stable natural lighting.",
  "image_end": "https://assets.example.com/landscape-end.jpg",
  "quality": "2k",
  "duration": 10
}

Steuern Sie sowohl den ersten als auch den letzten Frame

{
  "model": "minimax-h3-image-to-video",
  "prompt": "The sealed package opens smoothly and the product rises into the final display position. Keep the logo legible and avoid sudden camera cuts.",
  "image_start": "https://assets.example.com/package-closed.png",
  "image_end": "https://assets.example.com/package-open.png",
  "quality": "2k",
  "duration": 8
}

Eingabebilder müssen:

• Verwenden Sie JPG, JPEG, PNG, WEBP, HEIC oder HEIF.
• Darf nicht größer als 30 MB sein.
• Breite und Höhe zwischen 256 und 5.760 Pixel haben.
• Sie haben ein Verhältnis von Breite zu Höhe zwischen 0,4 und 2,5.
• Über eine öffentliche HTTP(S)-URL verfügbar sein.

10. Referenzvideo-Beispiel

„Reference-to-Video“ akzeptiert geordnete Arrays von Bildern, Videos und optionalem Audio. Dies ist nützlich, wenn einen Prompt allein das Thema, die Bewegung oder das Tempo nicht präzise genug beschreiben kann.

{
  "model": "minimax-h3-reference-to-video",
  "prompt": "Use Image 1 for the main character and Image 2 for the wardrobe. Follow the camera movement and walking rhythm from Video 1. Use Audio 1 only as a pacing reference. The character crosses a modern gallery and stops beside a large window.",
  "image_urls": [
    "https://assets.example.com/character.jpg",
    "https://assets.example.com/wardrobe.jpg"
  ],
  "video_urls": [
    "https://assets.example.com/camera-reference.mp4"
  ],
  "audio_urls": [
    "https://assets.example.com/pacing-reference.mp3"
  ],
  "quality": "2k",
  "duration": 10
}

Referenzgrenzen

• Bis zu 9 Artikel in image_urls.
• Bis zu 3 Artikel in video_urls.
• Bis zu 3 Artikel in audio_urls.
• Insgesamt höchstens 12 Referenzdateien, ein volles 9 + 3 + 3 wird also abgelehnt.
• Es ist mindestens ein Bild oder Video erforderlich.
• Audio kann nicht der einzige Referenztyp sein.
• Referenzvideo- und Audioclips müssen jeweils 2–15 Sekunden lang sein.
• Die Gesamtdauer des Referenzvideos darf 15 Sekunden nicht überschreiten.
• Die Gesamtdauer des Referenzaudios darf 15 Sekunden nicht überschreiten.
• Referenzvideos müssen MP4 oder MOV mit H.264- oder H.265-Video verwenden und können AAC- oder MP3-Audio enthalten.
• Jedes Referenzvideo kann bis zu 50 MB groß sein.
• Die Abmessungen des Referenzvideos müssen 256–5.760 Pixel pro Seite betragen, mit einem Breite-zu-Höhe-Verhältnis von 0,4 bis 2,5 und einer Bildrate von 23,976 bis 60 FPS.
• Referenzaudio muss WAV oder MP3 sein und kann bis zu 15 MB pro Clip groß sein.
• Der vollständige JSON-Anfragetext muss unter 64 MB bleiben.

Für Referenzbilder gelten dieselben Format-, Größen-, Dimensions- und URL-Regeln wie für die Bild-zu-Video-Umwandlung.

Beziehen Sie sich auf Medien nach Array-Reihenfolge

Die Dauer des Referenzvideos trägt zur abrechenbaren Nutzung bei. Vermeiden Sie daher das Anhängen längerer Clips als für die Aufgabe erforderlich.

11. Laden Sie lokale Medien hoch

Für die Generierungsrouten sind öffentliche HTTP(S)-Medien-URLs erforderlich. Um eine Datei von einer lokalen Festplatte oder einem privaten Anwendungs-Upload zu verwenden, senden Sie sie zunächst an den EvoLink-Dateidienst.

curl -X POST https://files-api.evolink.ai/api/v1/files/upload/stream \
  -H "Authorization: Bearer $EVOLINK_API_KEY" \
  -F "file=@./product-start.png"

12. Komplette TypeScript-Implementierung

Führen Sie dieses Beispiel in einer vertrauenswürdigen Serverumgebung auf Node.js 18 oder höher aus.

const API_BASE = "https://api.evolink.ai";

type TaskStatus = "pending" | "processing" | "completed" | "failed";

interface VideoTask {
  id: string;
  status: TaskStatus;
  results?: string[];
  error?: {
    code?: string;
    message?: string;
  };
}

interface BaseRequest {
  prompt: string;
  quality?: "2k";
  duration?: number;
  callback_url?: string;
}

type AspectRatio =
  | "adaptive"
  | "21:9"
  | "16:9"
  | "4:3"
  | "1:1"
  | "3:4"
  | "9:16";

// Ein Typ pro Route, damit eine ungültige Feldkombination nicht kompiliert.
interface TextToVideoRequest extends BaseRequest {
  model: "minimax-h3-text-to-video";
  aspect_ratio?: AspectRatio;
}

interface ImageToVideoRequest extends BaseRequest {
  model: "minimax-h3-image-to-video";
  image_start?: string;
  image_end?: string;
  // Kein aspect_ratio: Die Route lehnt das Feld ab und leitet das
  // Seitenverhältnis aus dem Eingabebild ab.
}

interface ReferenceToVideoRequest extends BaseRequest {
  model: "minimax-h3-reference-to-video";
  aspect_ratio?: AspectRatio;
  image_urls?: string[];
  video_urls?: string[];
  audio_urls?: string[];
}

type VideoRequest =
  | TextToVideoRequest
  | ImageToVideoRequest
  | ReferenceToVideoRequest;

function getApiKey(): string {
  const apiKey = process.env.EVOLINK_API_KEY;

  if (!apiKey) {
    throw new Error("EVOLINK_API_KEY is not configured");
  }

  return apiKey;
}

async function requestJson<T>(
  path: string,
  init?: RequestInit,
): Promise<T> {
  const response = await fetch(`${API_BASE}${path}`, {
    ...init,
    headers: {
      Authorization: `Bearer ${getApiKey()}`,
      "Content-Type": "application/json",
      ...init?.headers,
    },
  });

  if (!response.ok) {
    const body = await response.text();
    throw new Error(`EvoLink request failed (${response.status}): ${body}`);
  }

  return response.json() as Promise<T>;
}

async function submitVideo(payload: VideoRequest): Promise<VideoTask> {
  return requestJson<VideoTask>("/v1/videos/generations", {
    method: "POST",
    body: JSON.stringify(payload),
  });
}

async function getTask(taskId: string): Promise<VideoTask> {
  return requestJson<VideoTask>(
    `/v1/tasks/${encodeURIComponent(taskId)}`,
  );
}

function wait(milliseconds: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, milliseconds));
}

async function waitForVideo(
  taskId: string,
  timeoutMs = 10 * 60 * 1000,
  pollIntervalMs = 5_000,
): Promise<string> {
  const deadline = Date.now() + timeoutMs;

  while (Date.now() < deadline) {
    const task = await getTask(taskId);

    if (task.status === "completed") {
      const resultUrl = task.results?.[0];

      if (!resultUrl) {
        throw new Error("Task completed without a result URL");
      }

      return resultUrl;
    }

    if (task.status === "failed") {
      throw new Error(task.error?.message ?? "Video generation failed");
    }

    await wait(pollIntervalMs);
  }

  throw new Error(`Timed out while waiting for task ${taskId}`);
}

async function main(): Promise<void> {
  const task = await submitVideo({
    model: "minimax-h3-text-to-video",
    prompt:
      "A slow aerial approach toward a coastal observatory at sunrise, " +
      "natural cloud movement, cinematic wide shot",
    quality: "2k",
    aspect_ratio: "16:9",
    duration: 6,
  });

  const videoUrl = await waitForVideo(task.id);
  console.log(videoUrl);
}

void main();

Ersetzen Sie bei Systemen mit hohem Volumen die anwendungsseitige Abfrage durch Callbacks und eine dauerhafte Auftragsaufzeichnung. Behalten Sie die Aufgaben-ID als primäre Verknüpfung zwischen Ihrer Anfrage, dem Abrechnungsdatensatz, den Protokollen und dem Ergebnis bei.

13. Vollständige Python-Implementierung

import os
import time
from typing import NotRequired, TypedDict, cast

import requests

API_BASE = "https://api.evolink.ai"
API_KEY = os.environ["EVOLINK_API_KEY"]
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}


class VideoError(TypedDict):
    code: NotRequired[str]
    message: NotRequired[str]


class VideoTask(TypedDict):
    id: str
    status: str
    results: NotRequired[list[str]]
    error: NotRequired[VideoError]


class VideoPayload(TypedDict):
    model: str
    prompt: str
    image_start: NotRequired[str]
    quality: NotRequired[str]
    duration: NotRequired[int]


def submit_video(payload: VideoPayload) -> VideoTask:
    response = requests.post(
        f"{API_BASE}/v1/videos/generations",
        headers=HEADERS,
        json=payload,
        timeout=30,
    )
    response.raise_for_status()
    return cast(VideoTask, response.json())


def get_task(task_id: str) -> VideoTask:
    response = requests.get(
        f"{API_BASE}/v1/tasks/{task_id}",
        headers=HEADERS,
        timeout=30,
    )
    response.raise_for_status()
    return cast(VideoTask, response.json())


def wait_for_video(
    task_id: str,
    timeout_seconds: int = 600,
    poll_interval_seconds: int = 5,
) -> str:
    deadline = time.monotonic() + timeout_seconds

    while time.monotonic() < deadline:
        task = get_task(task_id)
        status = task["status"]

        if status == "completed":
            results = task.get("results", [])
            if not results:
                raise RuntimeError("Task completed without a result URL")
            return str(results[0])

        if status == "failed":
            error = task.get("error", {})
            message = error.get("message", "Video generation failed")
            raise RuntimeError(message)

        time.sleep(poll_interval_seconds)

    raise TimeoutError(f"Timed out while waiting for task {task_id}")


task = submit_video(
    {
        "model": "minimax-h3-image-to-video",
        "prompt": (
            "The camera slowly orbits the product while the background "
            "light shifts from warm to cool. Preserve the product design."
        ),
        "image_start": "https://assets.example.com/product.webp",
        "quality": "2k",
        "duration": 8,
    }
)

print(wait_for_video(task["id"]))

In diesem Beispiel bleibt die Abhängigkeit gering, während die Felder, die es nutzt, weiterhin deklariert werden. Validieren Sie bei einem größeren Python-Dienst die vollständige Antwort mit Pydantic, bevor Sie sie speichern.

14. Parameter- und Prompt-Übersicht

Parameterunterstützung

Promptmuster: Text-zu-Video

[subject] + [action] + [environment] + [camera movement] +
[lighting] + [visual mood]

Beispiel:

Ein Radfahrer überquert im Morgengrauen eine Hängebrücke über einem nebligen Wald. Die Kamera folgt von hinten und erhebt sich dann zu einem weiten Luftbild. Sanftes natürliches Licht und realistische Bewegung.

Promptmuster: Bild-zu-Video

[motion to add] + [camera movement] + [elements to preserve] +
[transition or ending state]

Beispiel:

Die Kamera dreht langsam einen Halbkreis um den Stuhl, während das Sonnenlicht über den Boden wandert. Behalten Sie die exakte Form, das Material und die Farbe des Stuhls bei.

Promptmuster: Referenzvideo

Use [Image/Video/Audio number] for [specific purpose].
[Describe the new scene, action, camera, and final composition.]

Beispiel:

Verwenden Sie Bild 1 für den Charakter, Bild 2 für das Fahrzeug und Video 1 für die Kamerabewegung. Der Charakter verlässt das Fahrzeug in einer ruhigen Wüste bei Sonnenuntergang, während die Kamera den gleichen Vorwärtsbogen wie in Video 1 macht.

15. Häufige Fehler und Korrekturen

Wiederholen Sie nur Fehler, die ohne Änderung der Anforderung erfolgreich sein können, z. B. vorübergehende Netzwerkausfälle oder Ratenbeschränkungen. Ungültige Parameter und nicht unterstützte Medien sollten vor einer weiteren Übermittlung korrigiert werden.

16. Preisgestaltung und Kostenplanung

Zu Planungszwecken:

• Eine längere Ausgabedauer erhöht den Arbeitsaufwand.
• Mit „Reference-to-Video“ kann auch die Dauer des Eingabe-Referenzvideos berechnet werden.
• Verwenden Sie bei der Validierung eines Prompts oder Workflows die kürzeste sinnvolle Dauer.
• Führen Sie vor einem großen Batch einige Testgenerierungen durch und prüfen Sie die Ergebnisse.
• Erfassen Sie für jede Aufgabe Modus, Ausgabedauer, Referenzvideodauer, Status und Kosten.
• Trennen Sie fehlgeschlagene Generierungen von nutzbaren Ergebnissen, wenn Sie die Kosten pro nutzbarem Video bewerten.

Mit der einheitlichen API von EvoLink kann ein Produktionsteam H3 auch mit anderen Videomodellen vergleichen, ohne die Authentifizierung, Aufgabenverfolgung und Abrechnungsintegration zu ersetzen.

17. Produktionscheckliste

Vor dem Versand:

• Behalten Sie den API-Schlüssel auf dem Server.
• Überprüfen Sie alle modusspezifischen Parameter vor der Übermittlung.
• Bestätigen Sie, dass Medien-URLs öffentlich sind und während der Generierung verfügbar bleiben.
• Legen Sie Zeitüberschreitungen für Anfragen fest.
• Begrenzte Abfragehäufigkeit und Gesamtabfragezeit.
• Zurückziehen nach 429 und vorübergehenden Serverfehlern.
• Speichern Sie die Aufgaben-ID, bevor Sie mit der Abfrage beginnen.
• Gehen Sie nicht davon aus, dass eine H3-Aufgabe abgebrochen werden kann. Der aktuelle Aufgabenvertrag meldet can_cancel: false.
• Behandeln Sie Callbacks als wiederholbare Ereignisse.
• Geben Sie eine 2xx-Callbackantwort erst zurück, nachdem Sie das Ereignis akzeptiert haben.
• Behalten Sie abgeschlossene Videos bei, bevor ihre temporären URLs ablaufen.
• Protokollieren Sie die Modell-ID, die Dauer, die Eingabereferenzen, den Status und das Ergebnis.
• Wenden Sie Parallelität und Budgetkontrollen auf Kontoebene an.
• Verlassen Sie sich nicht auf undokumentierte Header oder Ausgabeeinstellungen.

18. Praktische Anwendungsfälle

19. FAQ

Wie greife ich auf die MiniMax H3-API zu?

Welche MiniMax H3-Modell-ID sollte ich verwenden?

Unterstützt MiniMax H3 2K-Video?

Unterstützt die API 4K oder 60 FPS?

Diese Kontrollen sind nicht Teil des aktuellen H3-API-Vertrags. Senden Sie keine undokumentierten Einstellungen für Qualität, Bildrate, Bitrate oder Codec.

Was ist die maximale Videodauer?

Der aktuelle Dauerbereich beträgt 4–15 Sekunden, wobei ein ganzzahliger Wert verwendet wird.

Kann ich ein lokales Bild hochladen?

Akzeptiert die Generierungs-API Base64-Bilder?

Nein. Verwenden Sie eine öffentliche HTTP(S)-URL.

Wie viele Referenzen kann ich verwenden?

„Reference-to-Video“ akzeptiert bis zu 9 Bilder, 3 Videos und 3 Audiodateien, vorbehaltlich der Beschränkungen pro Datei und Gesamtdauer.

Kann ich ein Video allein aus einer Audioreferenz generieren?

Nein. Eine Referenzanfrage muss mindestens ein Bild oder Video enthalten. Audio kann als weitere Referenz hinzugefügt werden.

Wie überprüfe ich den Generierungsstatus?

Wie lange ist die generierte Video-URL verfügbar?

Die Ergebnis-URL ist 24 Stunden lang verfügbar. Laden Sie das Video herunter oder verschieben Sie es in Ihren eigenen Speicher, bevor es abläuft.

Kann ich MiniMax H3 über JavaScript oder Python verwenden?

Ja. Die API ist Standard-HTTPS und kann von jeder serverseitigen Umgebung aus aufgerufen werden, die JSON-Anfragen und Bearer-Authentifizierung unterstützt.

Soll ich die Aufgabe abfragen oder einen Callback verwenden?

Die Abfrage ist praktisch für Tests und Skripts mit geringem Volumen. Callbacks sind im Allgemeinen bei Produktionswarteschlangen und größeren Arbeitslasten effizienter.

Jetzt integrieren

• Probieren Sie MiniMax H3 aus und sehen Sie sich die Modelldetails an
• Erstellen Sie einen EvoLink-API-Schlüssel
• Überprüfen Sie die aktuellen MiniMax H3-Preise
• Öffnen Sie die Text-zu-Video-API-Referenz
• Öffnen Sie die Bild-zu-Video-API-Referenz
• Öffnen Sie die Referenzvideo-API-Referenz