Video

Generate a video from a script, idea, or blog URL. Supports automatic visual selection, AI-generated visuals, voiceover, subtitles, and more.

Request

POSThttps://api.fliki.ai/v1/generate/video

Headers

{
  "Content-type": "application/json",
  "Authorization": "Bearer API_KEY"
}

Key	Value	Description
Content-Type	application/json	Specifies that the request body format is JSON, allowing the server to parse the data correctly.
Authorization	Bearer `YOUR_API_KEY`	Generate your API Key in the automation section and replace `YOUR_API_KEY` with your actual key. API access is available on request — contact support to enable it for your account.

Body

{
  "file": String,      // optional name for the folder created in your workspace
  "payload": [
    {
      "workflowType": "script" | "idea" | "url",
      "workflowFormat": "video",

      // Input — required field depends on workflowType
      "content": String,   // required for "script" (script text) and "url" (blog/article URL)
      "prompt": String,    // required for "idea" (topic or idea)

      "voiceId": String,
      "aspectRatio": "16:9" | "9:16" | "1:1",
      "resolution": "1080p" | "720p" | "480p" | "360p",
      "extension": "mp4" | "mov" | "mp3" | "wav",
      "duration": Number,
      "visuals": "stock" | "ai" | "library",
      "mediaUrls": [String],   // public image URLs from your library; mixes with stock/ai, or set visuals:"library" for library only
      "artStyle": String,      // see Field values section for valid keys
      "aiVideoModel": "runware-seedance-pro-fast" | "runware-p-video" | "runware-pixverse-v5-fast" | "runware-ltx-2-fast" | "runware-kling-2.5-turbo",
      "aiVideoClipPercentage": Number,
      "imageAnimationPreset": "None" | "Mix:Subtle Flow" | "Mix" | "Mix:Dramatic",
      "bgMusicVolume": Number,
      "generateSfx": Boolean,
      "addPauses": Boolean,
      "subtitlePresetId": String,
      "highlightSubtitles": Boolean,
      "templateId": String,
      "sceneBreakdown": "auto" | "lineBreak" | "sentence",
      "fileName": String,
      "shouldExport": Boolean
    }
  ]
}

Pass multiple objects in payload to generate several videos in one request.

Top-level fields:

Key	Type	Description	Required	Default
payload	array	Array of video job objects (see below). Send one or many.	Yes	N/A
file	string	Name for the folder created in your workspace.	-	N/A
folderId	string	ID of an existing workspace folder to place files into. Find it by opening a folder in Fliki and copying the ID after `?folder=` in the URL. If omitted, a new folder named by `file` is created.	-	N/A

Each object in payload:

Key	Type	Description	Required	Default
workflowType	string	Type of video to generate. One of `script`, `idea`, or `url`.	Yes	N/A
workflowFormat	string	Must be `video`.	Yes	N/A
content	string	The script text (for `script`) or a blog/article URL (for `url`). Max 10000 characters.	Yes (for `script` / `url`)	N/A
prompt	string	The topic or idea to generate a video about. Max 10000 characters.	Yes (for `idea`)	N/A
voiceId	string	The identifier for the voice to be used for the voiceover.	Yes	N/A
aspectRatio	string	Output aspect ratio. One of `16:9`, `9:16`, or `1:1`.	-	`16:9`
resolution	string	Export resolution. One of `1080p`, `720p`, `480p`, or `360p`. Video only.	-	`1080p`
extension	string	Export format. `mp4` or `mov` for video; `mp3` or `wav` for audio.	-	`mp4`
duration	number	Target video duration in minutes (1–15, subject to your plan's max export length).	-	N/A
visuals	string	Fill source. `stock` uses stock footage; `ai` generates visuals with AI; `library` uses only your `mediaUrls`.	-	`stock`
mediaUrls	array	Public image URLs (max 100) imported into your media library and used as scene visuals — your own media (the "My library" source). Combines with the `visuals` fill source; set `visuals` to `library` to use these only. Required when `visuals` is `library`.	Yes (for `library`)	N/A
artStyle	string	Art style for AI-generated visuals. Used when `visuals` is `ai`. See valid values.	-	`cinematic`
aiVideoModel	string	AI video model for generating video clips instead of static images. Requires a paid plan. See valid values.	-	N/A
aiVideoClipPercentage	number	Percentage of scenes (0–100) to fill with AI video clips. Only applies when `aiVideoModel` is set.	-	`20`
imageAnimationPreset	string	Motion preset applied to AI-generated images. See valid values.	-	N/A
bgMusicVolume	number	Background music volume from `0` (muted) to `100` (full).	-	`20`
generateSfx	boolean	Automatically generate contextual sound effects for each scene.	-	`true`
addPauses	boolean	Insert natural pauses between sentences in the voiceover.	-	`false`
subtitlePresetId	string	ID of a subtitle preset. Get it from any project: open a file at app.fliki.ai/files → right panel → subtitle preset → copy icon. Only applies when `templateId` is not set.	-	N/A
highlightSubtitles	boolean	Highlight the currently spoken word in subtitles (karaoke style).	-	`false`
templateId	string	ID of a Fliki template to apply to the video. See Finding IDs.	-	N/A
sceneBreakdown	string	How to split the script into scenes. See valid values.	-	`auto`
fileName	string	Name for the created file shown in your Fliki workspace.	-	`Untitled file`
shouldExport	boolean	Automatically export the file after generation.	-	`false`

Finding voice and template IDs

Voice IDs — Browse all available voices and copy their IDs at fliki.ai/info/voice.
Template IDs — Browse all available templates and copy their IDs at fliki.ai/info/template.

Field values

artStyle — Art style for AI-generated images. Only applies when visuals is ai.

Value	Label
`cinematic`	Cinematic
`realistic`	Realistic
`anime`	Anime
`illustration`	Illustration
`comicBook`	Comic book
`threeDimensionModel`	3D model
`fantasyArt`	Fantasy art
`waterColor`	Watercolor
`lineArt`	Line art
`modelingCompound`	Clay
`whimsical`	Whimsical
`biblical`	Biblical
`filmNoir`	Film Noir
`tinyWorld`	Tiny World
`technicalIllustration`	Technical illustration

aiVideoModel — AI model used to generate video clips (paid plans only). Leave unset to skip AI video and use stock footage or static AI images instead.

Value	Name	Notes
`runware-seedance-pro-fast`	Seedance Pro Fast	Fastest and most affordable; good for drafts and B-roll
`runware-p-video`	P-Video	Affordable everyday model for social and marketing clips
`runware-pixverse-v5-fast`	PixVerse v5 Fast	Best for anime, sci-fi, and template-driven viral effects
`runware-ltx-2-fast`	LTX-2 Fast	Open-source model; supports clips up to 20 seconds
`runware-kling-2.5-turbo`	Kling 2.5 Turbo	Cinematic look with weighted physics; great for B-roll

imageAnimationPreset — Motion applied to AI-generated images. Has no effect when visuals is stock.

Value	Description
`None`	No motion — images are static
`Mix:Subtle Flow`	Gentle Ken Burns-style movement
`Mix`	Energetic short-form motion (TikTok style)
`Mix:Dramatic`	Bold, high-impact motion

sceneBreakdown — Controls how the script is split into scenes.

Value	Description
`auto`	AI decides the best split points (recommended)
`lineBreak`	Split at every new line
`sentence`	Split at every sentence

Response

{
  "success": Boolean,
  "data": {
    "folderId": String,
    "filesCreated": [String]
  }
}

Key	Type	Description
success	boolean	`true` when the jobs were scheduled successfully
data.folderId	string	Identifier of the folder containing the generated files
data.filesCreated	string[]	Array of file IDs, one per object submitted in `payload`

Checking Status

Video generation is asynchronous. Poll the status endpoint every 10 seconds using a fileId from data.filesCreated.

GET https://api.fliki.ai/v1/generate/status?fileId=<fileId>

{
  "fileId": String,
  "status": "queued" | "processing" | "success" | "error" | "canceled",
  "progress": Number,
  "download": String  // CDN URL — only present when status is "success"
}

Once status is success, the download field contains the MP4 URL.

Opening in Editor

To edit the generated video in Fliki, open:

https://app.fliki.ai/editor/<fileId>

Limits

Rate limit: 10 requests per 10 minutes per API key
Pending job cap: 20 queued or processing jobs at a time

Example

Bash
TypeScript
Python
Go

cURL Request
curl \
  -H "Authorization: Bearer <API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{"payload": [{"workflowType": "script", "workflowFormat": "video", "content": "Your script here...", "voiceId": "..."}]}' \
  -X POST https://api.fliki.ai/v1/generate/video

TypeScript Request
const apiKey = '<API_KEY>';
const url = 'https://api.fliki.ai/v1/generate/video';

const data = {
payload: [
  {
    workflowType: 'script',
    workflowFormat: 'video',
    content: 'Your script here...',
    voiceId: '...',
    aspectRatio: '16:9',
    visuals: 'stock',
    resolution: '1080p',
    shouldExport: true,
  },
],
};

async function generateVideo() {
const response = await fetch(url, {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${apiKey}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify(data),
});

const result = await response.json();
const fileId = result.data.filesCreated[0];

// Poll for status
while (true) {
  await new Promise((r) => setTimeout(r, 10000));
  const statusRes = await fetch(
    `https://api.fliki.ai/v1/generate/status?fileId=${fileId}`,
    { headers: { Authorization: `Bearer ${apiKey}` } }
  );
  const status = await statusRes.json();
  if (status.status === 'success') {
    console.log('Download URL:', status.download);
    break;
  }
  if (status.status === 'error' || status.status === 'canceled') {
    console.error('Generation failed:', status.status);
    break;
  }
}
}

generateVideo();

Python Request
import requests
import time

api_key = "<API_KEY>"
url = "https://api.fliki.ai/v1/generate/video"
headers = {
  "Authorization": f"Bearer {api_key}",
  "Content-Type": "application/json"
}
data = {
  "payload": [
      {
          "workflowType": "script",
          "workflowFormat": "video",
          "content": "Your script here...",
          "voiceId": "...",
          "aspectRatio": "16:9",
          "visuals": "stock",
          "resolution": "1080p",
          "shouldExport": True,
      }
  ]
}

response = requests.post(url, headers=headers, json=data)
file_id = response.json()["data"]["filesCreated"][0]

# Poll for status
while True:
  time.sleep(10)
  status_res = requests.get(
      f"https://api.fliki.ai/v1/generate/status?fileId={file_id}",
      headers=headers
  )
  status = status_res.json()
  if status["status"] == "success":
      print("Download URL:", status["download"])
      break
  if status["status"] in ("error", "canceled"):
      print("Generation failed:", status["status"])
      break

Go Request
package main

import (
"bytes"
"encoding/json"
"fmt"
"net/http"
"time"
)

func main() {
apiKey := "<API_KEY>"
url := "https://api.fliki.ai/v1/generate/video"

data := map[string]interface{}{
  "payload": []map[string]interface{}{
    {
      "workflowType":   "script",
      "workflowFormat": "video",
      "content":        "Your script here...",
      "voiceId":        "...",
      "aspectRatio":    "16:9",
      "visuals":        "stock",
      "resolution":     "1080p",
      "shouldExport":   true,
    },
  },
}
jsonData, _ := json.Marshal(data)

req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
filesCreated := result["data"].(map[string]interface{})["filesCreated"].([]interface{})
fileID := filesCreated[0].(string)

// Poll for status
for {
  time.Sleep(10 * time.Second)
  statusReq, _ := http.NewRequest("GET",
    fmt.Sprintf("https://api.fliki.ai/v1/generate/status?fileId=%s", fileID), nil)
  statusReq.Header.Set("Authorization", "Bearer "+apiKey)
  statusResp, _ := client.Do(statusReq)

  var status map[string]interface{}
  json.NewDecoder(statusResp.Body).Decode(&status)

  if status["status"] == "success" {
    fmt.Println("Download URL:", status["download"])
    break
  }
  if status["status"] == "error" || status["status"] == "canceled" {
    fmt.Println("Generation failed:", status["status"])
    break
  }
}
}

Request​

Headers​

Body​

Finding voice and template IDs​

Field values​

Response​

Checking Status​

Opening in Editor​

Limits​

Example​