Eine Video-API für KI-Apps, Automatisierung und SaaS-Produkte

Nutze eine einzige REST-API, um Produktvideos, Social Clips, personalisierte Ausgaben und agentengesteuerte Videos über Schemas, Vorschauen, formale Tasks, Rendering, Dateien und Webhooks zu erzeugen.

Schnellstart

In wenigen Minuten vom Schema zur Vorschau, zum Task, zum Render und zum Webhook.

1. API-Key holen
Erstelle in deinem Dashboard einen API-Key für die serverseitige Nutzung.
2. Schema einreichen
Erstelle eine temporäre Vorschau oder einen formalen Task, damit die Videogenerierung in einen nachverfolgbaren Workflow übergeht.
3. Ergebnisse empfangen
Starte das Rendering und erhalte die finale Ausgabe per Statusabfrage oder Webhook.

Empfohlener Ablauf: preview oder task erstellen -> rendern -> Status pollen / Webhook empfangen

Codebeispiele

Die folgenden Beispiele zeigen den Standardpfad für produktionsnahe Integrationen. Typische Anwendungsfälle sind Marketingvideos, Produktvideos, KI-Agent-Ausgaben und wiederholbare Content-Workflows.

curl -X POST 'https://renderingvideo.com/api/v1/video' \
  -H 'Authorization: Bearer sk-your-api-key' \
  -H 'Content-Type: application/json' \
  -d '{
    "config": {
      "meta": {
        "version": "2.0.0",
        "width": 1920,
        "height": 1080,
        "fps": 30,
        "background": "#000000"
      },
      "tracks": [
        {
          "clips": [
            {
              "type": "text",
              "text": "Hello World",
              "start": 0,
              "duration": 5
            }
          ]
        }
      ]
    }
  }'

curl -X POST 'https://renderingvideo.com/api/v1/video/<taskId>/render' \
  -H 'Authorization: Bearer sk-your-api-key' \
  -H 'Content-Type: application/json' \
  -d '{
    "webhook_url": "https://your-server.com/renderingvideo-webhook",
    "num_workers": 5
  }'

Kern-APIs

Zentrale Schnittstellen für Vorschauen, Tasks, Rendering, Dateien und nutzungsbasierte Credits über Produkt- und Automatisierungs-Workflows hinweg.

POST
/api/v1/video
Formalen Task erstellen

Erstelle aus einem Schema einen nachverfolgbaren formalen Task, ohne das Rendering sofort zu starten.

GET
/api/v1/video
Formale Tasks auflisten

Lies die Task-Liste deines Accounts mit Pagination für Dashboards und Backend-Synchronisierung.

GET
/api/v1/video/:taskId
Task-Details lesen

Gibt Maße, Dauer, Status, Ausgabe-URLs, Metadaten und wichtige Zeitstempel eines Tasks zurück.

DELETE
/api/v1/video/:taskId
Formalen Task löschen

Löscht lokale Task-Datensätze und versucht, den Upstream-Task ebenfalls zu bereinigen.

POST
/api/v1/video/:taskId/render
Formales Rendering auslösen

Schickt einen bestehenden Task in das Rendering. Unterstützt num_workers und webhook_url.

POST
/api/v1/upload
Assets hochladen

Lade Bild-, Video- und Audiodateien hoch, um sie in Vorschau- und Render-Workflows wiederzuverwenden.

GET
/api/v1/files
Assets auflisten

Durchsuche die Dateibibliothek mit Pagination und Typfiltern für Bilder, Videos und Audio.

DELETE
/api/v1/files/:fileId
Asset löschen

Entfernt Asset-Datensätze und gespeicherte Objekte, um die Bibliothek sauber zu halten.

GET
/api/v1/credits
Verfügbare Credits prüfen

Prüfe deinen verbleibenden Credit-Saldo vor dem formalen Rendering.

POST
/api/v1/preview
Temporäre Vorschau erstellen

Erzeuge Vorschau-Links ohne formale Render-Credits zu verbrauchen. Vorschau-Links laufen standardmäßig nach 7 Tagen ab.

GET
/api/v1/preview/:tempId
Vorschau-Konfiguration lesen

Prüfe das aktuell hinter einem temporären Vorschau-Link gespeicherte Schema.

DELETE
/api/v1/preview/:tempId
Vorschau-Link löschen

Entferne temporäre Vorschauen vor ihrem Ablauf.

POST
/api/v1/preview/:tempId/convert
Vorschau in Task umwandeln

Kopiert eine validierte Vorschau in einen formalen Task, ohne ihn sofort zu rendern.

POST
/api/v1/preview/:tempId/render
Vorschau umwandeln und rendern

Wandelt eine Vorschau direkt in einen formalen Task um und schickt ihn sofort ins Rendering.

Webhook-Benachrichtigungen
Dafür gebaut, Render-Ergebnisse in deine eigenen Systeme zurückzugeben.

Wenn du webhook_url bei einer Render-Anfrage mitsendest, sendet RenderingVideo eine POST-Anfrage an deinen Endpunkt, sobald der Task erfolgreich oder fehlgeschlagen ist. Das passt zu Datenbank-Updates, Produkt-Callbacks oder Folgeaktionen von Agenten. Aktuelle Events sind completed und failed.

{
  "taskId": "abc123def456",
  "renderTaskId": "rt_002",
  "status": "completed",
  "videoUrl": "https://storage.../videos/abc123.mp4",
  "error": null,
  "timestamp": "2026-03-23T10:00:00.000Z"
}

Integrationswerkzeuge

Nutze SDKs, um RenderingVideo schneller in bestehende Services einzubinden.

Node.js SDK
npm install @renderingvideo/sdk
import { RenderingVideo } from '@renderingvideo/sdk';

const client = new RenderingVideo({ apiKey: 'sk-xxx' });
const task = await client.video.create({
  meta: {
    version: '2.0.0',
    width: 1920,
    height: 1080,
    fps: 30,
    background: '#000000',
  },
  tracks: [...],
});
const render = await client.video.render(task.taskId, {
  webhook_url: 'https://your-server.com/renderingvideo-webhook',
});
console.log(render.status);
Auf GitHub ansehen
Python SDK
pip install renderingvideo
from renderingvideo import Client

client = Client(api_key="sk-xxx")
task = client.video.create({
    "meta": {
        "version": "2.0.0",
        "width": 1920,
        "height": 1080,
        "fps": 30,
        "background": "#000000"
    },
    "tracks": [...]
})

render = client.video.render(
    task.task_id,
    webhook_url="https://your-server.com/renderingvideo-webhook"
)
print(render.status)
Auf GitHub ansehen
PHP SDK
composer require renderingvideo/php-sdk
use RenderingVideo\Client;

$client = new Client('sk-xxx');
$task = $client->video->create([
    'meta' => [
        'version' => '2.0.0',
        'width' => 1920,
        'height' => 1080,
        'fps' => 30,
        'background' => '#000000'
    ],
    'tracks' => [...]
]);

$render = $client->video->render(
    $task->task_id,
    ['webhook_url' => 'https://your-server.com/webhook']
);
echo $render->status;
Auf GitHub ansehen

Authentifizierung

Alle serverseitigen API-Anfragen benötigen einen API-Key.

Unterstützte Authentifizierungsmethoden

Authorization-Header (empfohlen)

Authorization: Bearer sk-your-api-key

Authorization: Token

Authorization: Token sk-your-api-key

X-API-Key-Header

X-API-Key: sk-your-api-key

Query-Parameter (nur zum Debuggen, nicht für Produktion)

?api_key=sk-your-api-key

Sicherheitshinweis: API-Keys gehören ausschließlich auf deinen Server. Lege sie niemals in Client-Code, Browser-Bundles oder öffentliche Repositories.

Bereit, Videogenerierung in dein Produkt zu bringen?

Binde Vorschauen, formale Tasks, Rendering und Ergebnis-Callbacks in deine KI-App, dein SaaS-Produkt oder deinen Automatisierungs-Workflow ein.