> ## 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.
# Multimodale Interaktion mit Gemini
> Bild-/Videogenerierung mit Gemini
## Imagen-Leitfaden
Imagen ist eine fortschrittliche Reihe von KI-Modellen zur Bildgenerierung, die von Google entwickelt wurden und in der Lage sind, hochwertige, realistische Bilder auf Basis von Textaufforderungen zu erstellen. Dieser Leitfaden hilft Ihnen zu verstehen, wie Sie die Imagen-API zur Bildgenerierung nutzen können, einschließlich Parametereinstellungen, Modellauswahl und Codebeispielen.
Verfügbare Modelle:
* imagen-4.0-ultra-generate-001
* imagen-4.0-generate-001
* imagen-4.0-fast-generate-001
* imagen-4.0-fast-generate-preview-06-06
* imagen-3.0-generate-002
1. Derzeit unterstützt Imagen nur englische Prompts. Bei der Integration empfiehlt es sich, eine automatische Übersetzung hinzuzufügen, damit Nutzer es ohne Sprachbarrieren verwenden können.
2. Die Leistung ist instabil, wenn große Textmengen gerendert werden. Es wird empfohlen, nur die wichtigsten Schlüsselwörter einzubeziehen.
### Modellparameter
Imagen unterstützt derzeit nur englische Prompts und bietet die folgenden Parameter:
* **numberOfImages**: Die Anzahl der zu generierenden Bilder, im Bereich von 1 bis 4 (inklusive). Der Standardwert ist 4.
* `imagen-4.0-ultra-generate-001` kann nur 1 Bild auf einmal generieren.
* **aspectRatio**: Ändert das Seitenverhältnis der generierten Bilder. Unterstützte Werte sind "1:1", "3:4", "4:3", "9:16" und "16:9". Der Standardwert ist "1:1".
* **personGeneration**: Erlaubt dem Modell, Bilder von Personen zu generieren. Unterstützt die folgenden Werte:
* "DONT\_ALLOW": Verhindert die Generierung von Bildern, die Personen enthalten.
* "ALLOW\_ADULT": Generiert Bilder von Erwachsenen, jedoch nicht von Kindern. Dies ist der Standardwert.
### Nutzungspreise
Die Kosten für die Nutzung der Imagen-API zur Bildgenerierung:
* imagen-4-ultra: \$0,06/Bild
* imagen-4: \$0,04/Bild
* imagen-4-fast: \$0,02/Bild
* imagen-3: \$0,03/Bild
Bitte beachten Sie, dass jeder API-Aufruf 1–4 Bilder generieren kann und Ihnen die tatsächlich generierte Anzahl an Bildern in Rechnung gestellt wird.
### Beispiel für einen API-Aufruf
Hier ist ein Python-Beispiel zur Bildgenerierung mit Imagen 3.0:
```py Imagen theme={null}
import os
import time
from google import genai
from google.genai import types
from PIL import Image
from io import BytesIO
client = genai.Client(
api_key="sk-***", # 🔑 Replace with your key generated on AiHubMix
http_options={"base_url": "https://aihubmix.com/gemini"},
)
# Currently only supports English prompts, performance is poor with large amounts of text
response = client.models.generate_images(
model='imagen-4.0-fast-generate-001',
prompt='A minimalist logo for a LLM router market company on a solid white background. trident in a circle as the main symbol, with ONLY text \'InferEra\' below.',
config=types.GenerateImagesConfig(
number_of_images=1,
aspect_ratio="1:1", # supports "1:1", "9:16", "16:9", "3:4", or "4:3".
)
)
script_dir = os.path.dirname(os.path.abspath(__file__))
output_dir = os.path.join(script_dir, "output")
os.makedirs(output_dir, exist_ok=True)
# Generate timestamp as filename prefix to avoid filename conflicts
timestamp = int(time.time())
# Save and display the generated images
if response and hasattr(response, 'generated_images') and response.generated_images:
for i, generated_image in enumerate(response.generated_images):
try:
image = Image.open(BytesIO(generated_image.image.image_bytes))
image.show()
file_name = f"imagen3_{timestamp}_{i+1}.png"
file_path = os.path.join(output_dir, file_name)
image.save(file_path)
print(f"Image saved to: {file_path}")
except Exception as e:
print(f"Error processing image {i+1}: {e}")
else:
print("Error: No valid image response received")
print(f"Response type: {type(response)}")
if response:
print(f"Response attributes: {dir(response)}")
if hasattr(response, 'generated_images'):
print(f"generated_images value: {response.generated_images}")
else:
print("Response is empty, please check API key and network connection")
```
### Tipps für Prompts
Das Erstellen effektiver Prompts ist entscheidend, um die gewünschten Bilder zu erhalten:
* Verwenden Sie detaillierte Beschreibungen einschließlich Motiv, Stil, Beleuchtung, Blickwinkel usw.
* Geben Sie künstlerische Stile an (wie cinematic, photorealistic, Anime-Stil usw.).
* Fügen Sie technische Details hinzu (wie DSLR, hochauflösend, detailreich usw.).
* Vermeiden Sie negative oder verbotene Inhalte.
* **Vermeiden Sie es, große Textmengen in Prompts einzufügen**, verwenden Sie nur Schlüsselwörter für stabilere Ergebnisse.
## Gemini-Bildgenerierung
Gemini bietet ebenfalls Fähigkeiten zur Bildgenerierung als Alternative an. Im Vergleich zu Imagen ist die Bildgenerierung von Gemini besser für Szenarien geeignet, die Kontextverständnis und logisches Schlussfolgern erfordern, anstatt das ultimative künstlerische Ausdrucksvermögen und die visuelle Qualität anzustreben.
**Hinweise:**
* Modell-ID: `gemini-2.5-flash-image-preview`
* Eingabe-/Ausgabepreise: Text: \$0,3→\$2,5/M Tokens; Bild: \$0,3→\$30/M Tokens
* Es müssen Parameter hinzugefügt werden, um neue Funktionen zu nutzen: `"modalities":["text","image"]`
* Bilder werden in Base64-Codierung übergeben und ausgegeben
* Standardhöhe für ausgegebene Bilder ist 1024 px
* Python-Aufrufe erfordern das neueste OpenAI SDK; führen Sie zuerst `pip install -U openai` aus
* Weitere Informationen finden Sie in der [offiziellen Gemini-Dokumentation](https://ai.google.dev/gemini-api/docs/image-generation)
**Referenzstruktur für die Eingabe:**
```json theme={null}
"modalities": ["text","image"]
{
"model": "gemini-2.5-flash-image-preview",
"messages": [
{
"role": "user",
"content": "Generate a landscape painting and provide a poem to describe it"
}
],
"modalities":["text","image"], //need to add image
"temperature": 0.7
}'
```
**Referenzstruktur für die Ausgabe:**
```json theme={null}
"choices":
[
{
"index": 0,
"message":
{
"role": "assistant",
"content": "Hello! How can I assist you today?",
"refusal": null,
"multi_mod_content": //📍 New addition
[
{
"text": "",
"inlineData":
{
"data":"base64 str",
"mimeType":"png"
}
},
{
"text": "hello",
"inlineData":
{
}
}
],
"annotations":
[]
},
"logprobs": null,
"finish_reason": "stop"
}
],
```
### Text-zu-Bild-Generierung
Eingabe: Text
Ausgabe: Text + Bild
```shell Curl theme={null}
IMG_PATH="/your_path/image.jpg"
if [[ "$(base64 --version 2>&1)" = *"FreeBSD"* ]]; then
B64FLAGS="--input"
else
B64FLAGS="-w0"
fi
IMG_BASE64=$(base64 "$B64FLAGS" "$IMG_PATH" 2>&1)
curl https://aihubmix.com/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer sk-***" \
-d '{
"model": "gemini-2.5-flash-image-preview",
"messages": [
{
"role": "user",
"content": [
{
"type":"text",
"text":"describe the image with a concise and engaging paragraph, then fill color as children's crayon style"
},
{
"type": "image_url",
"image_url": {
"url": "data:image/jpeg;base64,'$IMG_BASE64'"
}
}
]
}
],
"modalities": ["text","image"],
"temperature": 0.7
}' \
| grep -o '"data":"[^"]*"' \
| cut -d'"' -f4 \
| base64 --decode > /your_path/imageGen.jpg
```
```py OpenAI Python theme={null}
import os
from openai import OpenAI
from PIL import Image
from io import BytesIO
import base64
client = OpenAI(
api_key="sk-***", # 🔑 Replace with your key generated on AiHubMix
base_url="https://aihubmix.com/v1",
)
# Using text-only input
response = client.chat.completions.create(
model="gemini-2.5-flash-image-preview",
messages=[
{
"role": "user",
"content": [
{
"type": "text",
"text": "generate an adorable mermaid in the sea, bold outline, chibi cartoon, in the style of Children coloring book, B&W",
}
],
},
],
modalities=["text", "image"],
temperature=0.7,
)
try:
# Print basic response information
print(f"Creation time: {response.created}")
print(f"Token usage: {response.usage.total_tokens}")
# Check if multi_mod_content field exists
if (
hasattr(response.choices[0].message, "multi_mod_content")
and response.choices[0].message.multi_mod_content is not None
):
print("\nResponse content:")
for part in response.choices[0].message.multi_mod_content:
if "text" in part and part["text"] is not None:
print(part["text"])
# Process image content
elif "inline_data" in part and part["inline_data"] is not None:
print("\n🖼️ [Image content received]")
image_data = base64.b64decode(part["inline_data"]["data"])
mime_type = part["inline_data"].get("mime_type", "image/png")
print(f"Image type: {mime_type}")
image = Image.open(BytesIO(image_data))
image.show()
# Save image
output_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "output")
os.makedirs(output_dir, exist_ok=True)
output_path = os.path.join(output_dir, "generated_image.png")
image.save(output_path)
print(f"✅ Image saved to: {output_path}")
else:
print("No valid multimodal response received, check response structure")
except Exception as e:
print(f"Error processing response: {str(e)}")
```
```py Gemini Python theme={null}
import mimetypes
from google import genai
from google.genai import types
import os
def save_binary_file(file_name, data):
f = open(file_name, "wb")
f.write(data)
f.close()
print(f"File saved to to: {file_name}")
def generate():
client = genai.Client(
api_key="sk-***", # 🔑 Replace with your key generated on AiHubMix
http_options={"base_url": "https://aihubmix.com/gemini"},
)
model = "gemini-2.5-flash-image-preview"
contents = [
types.Content(
role="user",
parts=[
types.Part.from_text(text="""generate image: an adorable mermaid in the sea, bold outline, chibi cartoon, in the style of Children coloring book, super cute, B&W, HD"""),
],
),
]
generate_content_config = types.GenerateContentConfig(
response_modalities=[
"IMAGE",
"TEXT",
],
)
file_index = 0
for chunk in client.models.generate_content_stream(
model=model,
contents=contents,
config=generate_content_config,
):
if (
chunk.candidates is None
or chunk.candidates[0].content is None
or chunk.candidates[0].content.parts is None
):
continue
if chunk.candidates[0].content.parts[0].inline_data and chunk.candidates[0].content.parts[0].inline_data.data:
file_name = f"ENTER_FILE_NAME_{file_index}"
file_index += 1
inline_data = chunk.candidates[0].content.parts[0].inline_data
data_buffer = inline_data.data
file_extension = mimetypes.guess_extension(inline_data.mime_type)
save_binary_file(f"{file_name}{file_extension}", data_buffer)
else:
print(chunk.text)
if __name__ == "__main__":
generate()
```
**Ausgabebeispiel:**
### Bild bearbeiten
Eingabe: Text + Bild\
Ausgabe: Text + Bild
```py Python theme={null}
import os
from openai import OpenAI
from PIL import Image
from io import BytesIO
import base64
client = OpenAI(
api_key="sk-***", # 🔑 Replace with your key generated on AiHubMix
base_url="https://aihubmix.com/v1",
)
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
image_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "resources", "filled.jpg")
if not os.path.exists(image_path):
raise FileNotFoundError(f"image {image_path} not exists")
def encode_image(image_path):
with open(image_path, "rb") as image_file:
return base64.b64encode(image_file.read()).decode("utf-8")
base64_image = encode_image(image_path)
response = client.chat.completions.create(
model="gemini-2.5-flash-image-preview",
messages=[
{
"role": "user",
"content": [
{
"type": "text",
"text": "describe the image with a concise and engaging paragraph, then fill color as children's crayon style",
},
{
"type": "image_url",
"image_url": {"url": f"data:image/jpeg;base64,{base64_image}"},
},
],
},
],
modalities=["text", "image"],
temperature=0.7,
)
try:
# Print basic response information without base64 data
print(f"Creation time: {response.created}")
print(f"Token usage: {response.usage.total_tokens}")
# Check if multi_mod_content field exists
if (
hasattr(response.choices[0].message, "multi_mod_content")
and response.choices[0].message.multi_mod_content is not None
):
print("\nResponse content:")
for part in response.choices[0].message.multi_mod_content:
if "text" in part and part["text"] is not None:
print(part["text"])
# Process image content
elif "inline_data" in part and part["inline_data"] is not None:
print("\n🖼️ [Image content received]")
image_data = base64.b64decode(part["inline_data"]["data"])
mime_type = part["inline_data"].get("mime_type", "image/png")
print(f"Image type: {mime_type}")
image = Image.open(BytesIO(image_data))
image.show()
# Save image
output_dir = os.path.join(os.path.dirname(image_path), "output")
os.makedirs(output_dir, exist_ok=True)
output_path = os.path.join(output_dir, "edited_image.jpg")
image.save(output_path)
print(f"✅ Image saved to: {output_path}")
else:
print("No valid multimodal response received, check response structure")
except Exception as e:
print(f"Error processing response: {str(e)}")
```
**Ausgabebeispiel:**
## Das richtige Modell wählen
### Wann Sie Gemini wählen sollten:
* Wenn Sie Weltwissen und Schlussfolgerungsfähigkeiten nutzen müssen, um kontextuell relevante Bilder zu generieren.
* Wenn Sie eine nahtlose Integration von Text und Bildern benötigen.
* Wenn Sie präzise visuelle Inhalte in lange Textsequenzen einbetten möchten.
* Wenn Sie Bilder im Dialog bearbeiten möchten, während der Kontext erhalten bleibt.
### Wann Sie Imagen wählen sollten:
* Wenn Bildqualität, Fotorealismus, künstlerische Details oder spezifische Stile (wie Impressionismus, Anime) im Vordergrund stehen.
* Wenn Sie professionelle Bearbeitungsaufgaben ausführen, wie Hintergrundaktualisierungen von Produkten oder Bildvergrößerung.
* Wenn Sie Branding, Stil einbringen oder Logos und Produktdesigns generieren möchten.
### Best Practices
1. **Prompts optimieren**: Sorgfältig gestaltete Prompts sind der Schlüssel zu hochwertigen Ergebnissen.
2. **Mit Parametern experimentieren**: Probieren Sie verschiedene Seitenverhältnisse und Einstellungen aus, um die für Ihre Bedürfnisse am besten geeignete Konfiguration zu finden.
3. **Batch-Generierung**: Generieren Sie mehrere Bilder, um die Chance zu erhöhen, ideale Ergebnisse zu erhalten.
4. **Metadaten speichern**: Speichern Sie Prompts und Zeitstempel zusammen mit den Bildern, um erfolgreiche Ergebnisse zu verfolgen und zu reproduzieren.
5. **Nutzungsrichtlinien einhalten**: Stellen Sie sicher, dass Ihre Nutzung den Inhaltsrichtlinien und Nutzungsbedingungen von Google entspricht.
## Veo 3.0 Videogenerierung
VEO 3.0 ist das neueste fortschrittliche Videogenerierungsmodell, das von Google DeepMind entwickelt wurde. Mit [VEO 3.0](https://aihubmix.com/models?model=veo-3.0-generate-preview) können Sie Videos mit den folgenden Funktionen generieren:
* Verbesserte Qualität aus Text- und Bild-Prompts
* Sprache, wie Dialoge und Voiceovers
* Audio, wie Musik und Soundeffekte
1. Derzeit unterstützt VEO 3.0 nur englische Prompts; für die Integration wird eine automatische Übersetzung empfohlen
2. Videos werden in der Regel innerhalb weniger Minuten generiert, in Spitzenzeiten kann es jedoch länger dauern
3. Die Videogenerierung aus bildbasierten Dialogen wird derzeit nicht unterstützt
### Bekannte Einschränkungen
Derzeit sind die Parameter von VEO 3.0 fest und können nicht geändert werden:
* **Auflösung**: 720p (Querformat)
* **Bildrate**: 24 fps
* **Videolänge**: 8 Sekunden
### Preise
Die Kosten der VEO 3.0 API betragen **\$0,675/Sekunde** (Aihubmix bietet einen zeitlich begrenzten Rabatt von 10 %)
### Anwendungsbeispiel
VEO 3.0 unterstützt derzeit nur curl-Befehlsaufrufe in einem zweistufigen Prozess:
Hinweis: `sk-***` ist Ihr auf AiHubMix generierter Key.
```shell Step 1: Initiate Generation Request theme={null}
curl "https://aihubmix.com/gemini/v1beta/models/veo-3.0-generate-preview:predictLongRunning?key=sk-***" \
-H "Content-Type: application/json" \
-X "POST" \
-d '{
"instances":
[
{
"prompt": "A cat playing with a ball"
}
],
"parameters":
{
"numberOfVideos": 1,
"durationSeconds": 8,
"aspectRatio": "16:9",
"personGeneration": "dont_allow"
}
}'
```
```shell Step 2: Get Generation Result theme={null}
# Use the operation ID from the name field returned in Step 1
curl "https://aihubmix.com/gemini/v1beta/models/veo-3.0-generate-preview/operations/ff5***?key=sk-***"
```
```py Video Extraction Script theme={null}
import json
import base64
# 1. Read the response JSON file
with open('yourpath/response.json', 'r') as f:
data = json.load(f)
# 2. Get the base64 encoded video string
b64_str = data['response']['videos'][0]['bytesBase64Encoded']
# 3. Decode and write to mp4 file
with open('output.mp4', 'wb') as f:
f.write(base64.b64decode(b64_str))
print("Video saved as output.mp4")
```
### Antwortbeispiele
**Antwort auf Schritt 1:**
```json theme={null}
{
"name": "models/veo-3.0-generate-preview/operations/ff5***"
}
```
**Antwort auf Schritt 2 (Generierung abgeschlossen):**
```json theme={null}
{
"name": "projects/ahm-gemini-03/locations/us-central1/publishers/google/models/veo-3.0-generate-preview/operations/ff5***",
"done": true,
"response": {
"@type": "type.googleapis.com/cloud.ai.large_models.vision.GenerateVideoResponse",
"raiMediaFilteredCount": 0,
"videos": [
{
"bytesBase64Encoded": "AAA...2xl",
"mimeType": "video/mp4"
}
]
}
}
```
**Antwort auf Schritt 2 (Verarbeitung läuft noch):**
```json theme={null}
{
"name": "projects/ahm-gemini-03/locations/us-central1/publishers/google/models/veo-3.0-generate-preview/operations/777***"
}
```
Wenn Sie eine Verarbeitungsantwort erhalten, warten Sie bitte einige Minuten und senden Sie die Anfrage aus Schritt 2 erneut.
**Videoeffekt:**
### Best Practices
1. **Geduld haben**: Die Videogenerierung dauert in der Regel einige Minuten, in Spitzenzeiten länger
2. **Status prüfen**: Wenn die Antwort kein `done: true` enthält, läuft die Verarbeitung noch
3. **Operation-ID speichern**: Stellen Sie sicher, dass Sie die in Schritt 1 zurückgegebene Operation-ID für nachfolgende Abfragen speichern
4. **Nutzungsrichtlinien einhalten**: Stellen Sie sicher, dass Ihre Nutzung den Inhaltsrichtlinien und Nutzungsbedingungen von Google entspricht
Weitere Informationen finden Sie in der [offiziellen Vertex AI-Dokumentation](https://cloud.google.com/vertex-ai/generative-ai/docs/video/generate-videos)
## Veo 2.0 Videogenerierung
VEO 2.0 ist ein fortschrittliches KI-Modell zur Videogenerierung, das von Google eingeführt wurde und in der Lage ist, hochwertige, realistische Kurzvideos auf Basis von Textaufforderungen zu erstellen. Dieser Abschnitt hilft Ihnen zu verstehen, wie Sie die VEO 2.0 API zur Videogenerierung verwenden können, einschließlich Parametereinstellungen, Modellauswahl und Codebeispielen.
1. Derzeit unterstützt VEO 2.0 nur englische Prompts
2. Die Videogenerierung dauert ungefähr 2–3 Minuten, bitte haben Sie Geduld
### Modellparameter
VEO 2.0 bietet die folgenden Parameter:
* **numberOfVideos**: Die Anzahl der zu generierenden Videos, Optionen sind 1 oder 2. Standard ist 2.
* **aspectRatio**: Das Seitenverhältnis der generierten Videos. Unterstützte Werte sind "16:9" und "9:16".
* **durationSeconds**: Videodauer, Optionen sind 5 Sekunden oder 8 Sekunden. Standard sind 8 Sekunden.
* **personGeneration**: Steuert, ob Videos mit Personen zugelassen werden. Unterstützt die folgenden Werte:
* "dont\_allow": Verhindert die Generierung von Videos, die Personen enthalten.
* "allow\_adult": Erlaubt die Generierung von Videos mit Erwachsenen, jedoch nicht mit Kindern.
### Preise
Die Kosten der VEO 2.0 API betragen \$0,35/s
### Anwendungsbeispiel
Hier ist ein Python-Beispiel für die Verwendung von VEO 2.0 zur Videogenerierung:
```py Generate from text theme={null}
import os
import time
from google import genai
from google.genai import types
client = genai.Client(
api_key="sk-***", # 🔑 Replace with your key generated on AiHubMix
http_options={"base_url": "https://aihubmix.com/gemini"},
)
operation = client.models.generate_videos(
model="veo-2.0-generate-001",
prompt="Panning wide shot of a calico kitten sleeping in the sunshine",
config=types.GenerateVideosConfig(
person_generation="dont_allow", # "dont_allow" or "allow_adult"
aspect_ratio="16:9", # "16:9" or "9:16"
number_of_videos=1, # Integer, options are 1 or 2, default is 2
durationSeconds=5, # Integer, options are 5 or 8, default is 8
),
)
# Takes 2-3 minutes, video duration is 5-8s
while not operation.done:
time.sleep(20)
operation = client.operations.get(operation)
for n, generated_video in enumerate(operation.response.generated_videos):
client.files.download(file=generated_video.video)
generated_video.video.save(f"video{n}.mp4") # Save the video
```
```py Generate from images theme={null}
import os
import time
from google import genai
from google.genai import types
def load_image(path):
with open(path, "rb") as image_file:
return image_file.read()
client = genai.Client(
api_key="sk-***", # 🔑 Replace with your key generated on AiHubMix
http_options={"base_url": "https://aihubmix.com/gemini"},
)
operation = client.models.generate_videos(
model="veo-2.0-generate-001",
prompt="The waves in the background keep flowing",
image=types.Image(
mime_type="image/png",
image_bytes=load_image("img/inferbanner.png") # your image path
),
config=types.GenerateVideosConfig(
person_generation="dont_allow",
aspect_ratio="16:9",
numberOfVideos=1,
durationSeconds=5,
),
)
while not operation.done:
time.sleep(20)
operation = client.operations.get(operation)
for n, generated_video in enumerate(operation.response.generated_videos):
client.files.download(file=generated_video.video)
generated_video.video.save(f"video{n}.mp4")
```
### Tipps für Prompts
Das Erstellen effektiver Prompts ist entscheidend, um die gewünschten Videos zu erhalten:
* Beschreiben Sie klare Szenen, Aktionen und Atmosphäre
* Geben Sie Aufnahmestile an (wie Panorama-, Nah-, Verfolgungsaufnahmen usw.)
* Beschreiben Sie Lichtverhältnisse (wie sonnig, Dämmerung, Innenbeleuchtung usw.)
* Geben Sie das Hauptmotiv und seine Aktionen an (z. B. "ein Kätzchen schläft in der Sonne")
* Vermeiden Sie übermäßig komplexe Erzählungen oder schnell wechselnde Szenen
* Vermeiden Sie negative oder verbotene Inhalte
### Best Practices
1. **Klare und präzise Prompts**: Verwenden Sie klare, spezifische Beschreibungen, um die Videogenerierung zu steuern.
2. **Geduld ist entscheidend**: Die Videogenerierung dauert 2–3 Minuten, bitte warten Sie auf den Abschluss.
3. **Verschiedene Parameter testen**: Probieren Sie verschiedene Seitenverhältnisse und Dauern aus, um die für Ihre Bedürfnisse am besten geeigneten Einstellungen zu finden.
4. **Generierungsaufzeichnungen speichern**: Notieren Sie die Prompts zusammen mit den generierten Videos, um erfolgreiche Ergebnisse nachvollziehen zu können.
5. **Nutzungsrichtlinien einhalten**: Stellen Sie sicher, dass Ihre Nutzung den Inhaltsrichtlinien und Nutzungsbedingungen von Google entspricht.
***
Zuletzt aktualisiert: 2026-06-01