DEV Community: deAPI

Getting Started with LTX-Video: Text-to-Video Generation API (Python)

deAPI — Tue, 02 Jun 2026 09:17:35 +0000

A 5-second AI video clip used to cost between $0.25 and $0.50 on platforms like Runway. Through deAPI, the same clip runs on LTX-Video models for $0.005 to $0.053 depending on model and resolution. This tutorial gets you from zero to a generated video in Python.

We'll cover three generation modes: text-to-video, image-to-video (animating a still image), and audio-to-video (lip-synced clips from an audio file). All three run through the same API with the same authentication.

What you'll need

Python 3.8+
The requests library (pip install requests)
A deAPI account - sign up at app.deapi.ai/dashboard and grab your API key from Settings -> API Keys. $5 in free credits, no card required.

Pick your model

deAPI runs three LTX-Video models. Each trades speed for quality:

Model	Slug	Max resolution	Audio sync	Price (768x768)
LTX-Video 13B	Ltxv_13B_0_9_8_Distilled_FP8	768x768	No	~$0.009 (~4s max)
LTX-2 19B	Ltx2_19B_Dist_FP8	1024x1024	No	~$0.041 (5s)
LTX-2.3 22B	Ltx2_3_22B_Dist_INT8	1024x1024	Yes	~$0.047 (5s)

Start with LTX-Video 13B for testing - it's the fastest and cheapest. Move to LTX-2.3 when you need higher quality or audio synchronization.

Your first video

Every deAPI request follows an async pattern: send a generation request, get back a request_id, poll until the result is ready. Here's the complete flow:

import requests
import time

API_KEY = "dpn-sk-your-key-here"
BASE = "https://api.deapi.ai/api/v2"
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Accept": "application/json",
    "Content-Type": "application/json"
}

# Generate a clip (120 frames at 30 fps = ~4 seconds, the LTX-Video 13B max)
response = requests.post(f"{BASE}/videos/generations", headers=HEADERS, json={
    "prompt": "A lighthouse on a rocky cliff during a storm at night. Rain hammers the rocks while the beam cuts through thick fog. Waves crash against the base, sending spray upward. Camera slowly pushes in from a wide shot. Cinematic, 35mm film grain.",
    "model": "Ltxv_13B_0_9_8_Distilled_FP8",
    "width": 512,
    "height": 512,
    "frames": 120,
    "fps": 30,
    "steps": 1,
    "guidance": 7.5,
    "seed": 42
})

request_id = response.json()["data"]["request_id"]
print(f"Request ID: {request_id}")

# Poll for the result
while True:
    result = requests.get(
        f"{BASE}/jobs/{request_id}",
        headers=HEADERS
    ).json()

    status = result["data"]["status"]
    print(f"Status: {status}")

    if status == "done":
        video_url = result["data"]["result_url"]
        print(f"Video URL: {video_url}")

        video = requests.get(video_url)
        with open("output.mp4", "wb") as f:
            f.write(video.content)
        print("Saved to output.mp4")
        break

    if status == "error":
        print(f"Error: {result['data']}")
        break

    time.sleep(3)

Generation takes 30-90 seconds depending on the model and resolution. The result URL returns an MP4 file.

Writing prompts that work

LTX-Video reads prompts like a language model, not a keyword parser. Three things make the biggest difference:

First: write in full sentences. "A 35-year-old woman with dark hair speaks to the camera in a modern office" beats "woman, dark hair, office, talking, 35yo." Front-load your subject - the model weighs earlier words more heavily.

Micro-motions matter more than you'd expect. Without explicit instructions like "subtle head nods" or "natural blinks," faces tend to freeze. A prompt that says "she speaks expressively, gesturing with her right hand" produces a fundamentally different clip than "a woman talking."

Camera movement is the other lever. Static or slow-dolly shots pair best with dialogue and faces. Save the sweeping drone moves for wide establishing shots where face coherence doesn't matter.

Aim for 60-200 words in your prompt. Below 60, the output gets generic. Past 200, you give the model enough detail to stay coherent across the full clip.

Image-to-video: animate a still

The image-to-video endpoint takes a still image and a motion prompt, then generates a clip where that image comes to life. Product photos and portraits work especially well - anything with a clear subject and defined edges.

import requests
import time

API_KEY = "dpn-sk-your-key-here"
BASE = "https://api.deapi.ai/api/v2"
HEADERS = {"Authorization": f"Bearer {API_KEY}", "Accept": "application/json"}

with open("portrait.jpg", "rb") as img:
    response = requests.post(f"{BASE}/videos/animations", headers=HEADERS,
        data={
            "prompt": "The woman slowly turns her head to the right, smiles gently, and looks directly at the camera. Soft natural light from a window. Shallow depth of field.",
            "model": "Ltx2_19B_Dist_FP8",
            "width": 768,
            "height": 768,
            "frames": 120,
            "fps": 24,
            "steps": 8,
            "guidance": 1,
            "seed": 42
        },
        files={"first_frame_image": ("portrait.jpg", img, "image/jpeg")}
    )

request_id = response.json()["data"]["request_id"]

while True:
    result = requests.get(
        f"{BASE}/jobs/{request_id}", headers=HEADERS
    ).json()
    if result["data"]["status"] == "done":
        video = requests.get(result["data"]["result_url"])
        with open("animated_portrait.mp4", "wb") as f:
            f.write(video.content)
        print("Saved to animated_portrait.mp4")
        break
    if result["data"]["status"] == "error":
        print(f"Error: {result['data']}")
        break
    time.sleep(3)

LTX-2 and LTX-2.3 also support a last_frame_image parameter. Pin both the start and end frames, and the model interpolates the motion between them - useful for controlled transitions in product demos.

Audio-to-video: lip-sync from speech

This is where LTX-2.3 stands alone. Feed it an audio file alongside a text prompt, and the generated character's mouth movements sync to the speech. Phoneme-level accuracy, not just generic "mouth opening and closing."

import requests
import time

API_KEY = "dpn-sk-your-key-here"
BASE = "https://api.deapi.ai/api/v2"
HEADERS = {"Authorization": f"Bearer {API_KEY}", "Accept": "application/json"}

with open("narration.mp3", "rb") as audio:
    response = requests.post(f"{BASE}/videos/audio-syncs", headers=HEADERS,
        data={
            "prompt": "A male news anchor in his 40s sits behind a studio desk, speaking directly to camera. Professional lighting, shallow depth of field on the background. He gestures occasionally with his right hand while maintaining eye contact.",
            "model": "Ltx2_3_22B_Dist_INT8",
            "width": 768,
            "height": 768,
            "frames": 120,
            "fps": 24,
            "seed": 42
        },
        files={"audio": ("narration.mp3", audio, "audio/mpeg")}
    )

request_id = response.json()["data"]["request_id"]

while True:
    result = requests.get(
        f"{BASE}/jobs/{request_id}", headers=HEADERS
    ).json()
    if result["data"]["status"] == "done":
        video = requests.get(result["data"]["result_url"])
        with open("lipsync_video.mp4", "wb") as f:
            f.write(video.content)
        print("Saved to lipsync_video.mp4")
        break
    if result["data"]["status"] == "error":
        print(f"Error: {result['data']}")
        break
    time.sleep(3)

Audio files can be up to 11 seconds long (MP3, WAV, OGG, or FLAC). For the strongest results, combine audio with a first_frame_image - the image locks the character's appearance while the audio drives every lip movement.

What it costs

Model	512x512	768x768	1024x1024
LTX-Video 13B	~$0.006	~$0.009	-
LTX-2 19B	-	~$0.041	~$0.046
LTX-2.3 22B	-	~$0.047	~$0.053

Note on clip length: LTX-Video 13B runs at a fixed 30 fps, so its 120-frame maximum is a ~4-second clip (the 512x512 figure above is for that clip). LTX-2 and LTX-2.3 run at 24 fps, so 120 frames is a true 5-second clip.

For comparison, Runway Gen-3 charges $0.25-0.50 per 5-second clip. Generating 100 test clips on LTX-Video 13B costs about $0.60 total - the kind of budget where you can iterate freely without watching a billing dashboard.

The $5 free credit covers roughly 800 clips on LTX-Video 13B, or about 100 on LTX-2.3 at 768x768.

What's next

Full API docs - all video endpoints, parameters, and model specs
Playground - generate videos in the browser before writing code
LTX-2.3 prompting guide - deep dive into prompt structure with worked examples

Pair video generation with deAPI's text-to-speech endpoint and you have a complete talking-head pipeline: generate the narration with Kokoro or Qwen3 TTS, then feed that audio straight into LTX-2.3. The lip-synced clip comes back ready to use.

OpenAI TTS Too Expensive? Switch to Kokoro in 2 Lines of Code

deAPI — Fri, 29 May 2026 11:43:12 +0000

If you're using OpenAI's text-to-speech API, you're paying $15 per million characters. Kokoro generates speech that sounds just as natural — for $0.77 per million characters. That's roughly 20x less.

You don't need to rewrite anything. Kokoro runs through an OpenAI-compatible endpoint on deAPI. Change base_url and api_key, keep the rest of your code identical.

This tutorial walks through the switch, covers voice options, and shows what else opens up once you're on deAPI — including voice cloning and voice design from a text description.

What you'll need

Python 3.8+ or Node.js 18+
The OpenAI SDK (pip install openai or npm install openai)
A deAPI account — sign up at app.deapi.ai/dashboard, grab your API key from Settings → API Keys. You get $5 in free credits, no credit card required.

The two-line migration

Here's your existing OpenAI TTS code:

from openai import OpenAI

client = OpenAI(api_key="sk-...")

audio = client.audio.speech.create(
    model="tts-1",
    voice="nova",
    input="Welcome back to the show. Today we're covering something interesting."
)

with open("output.mp3", "wb") as f:
    f.write(audio.content)

Now here's the deAPI version:

from openai import OpenAI

client = OpenAI(
    api_key="dpn-sk-your-key-here",       # <- line 1
    base_url="https://oai.deapi.ai/v1"    # <- line 2
)

audio = client.audio.speech.create(
    model="Kokoro",
    voice="af_nova",
    input="Welcome back to the show. Today we're covering something interesting."
)

with open("output.mp3", "wb") as f:
    f.write(audio.content)

Two parameters changed. The rest — client.audio.speech.create(), the response object, writing to file — stays identical. If you have a wrapper function around OpenAI TTS, you're looking at a 30-second migration.

The same works in Node.js:

import OpenAI from "openai";
import { writeFileSync } from "fs";

const client = new OpenAI({
  apiKey: "dpn-sk-your-key-here",
  baseURL: "https://oai.deapi.ai/v1",
});

const audio = await client.audio.speech.create({
  model: "Kokoro",
  voice: "af_nova",
  input: "Welcome back to the show. Today we're covering something interesting.",
});

const buffer = Buffer.from(await audio.arrayBuffer());
writeFileSync("output.mp3", buffer);

Picking a voice

Kokoro ships with 40+ voices across seven languages. Here are the ones most OpenAI users will reach for first:

OpenAI voice	Kokoro equivalent	Gender	Accent
alloy	af_alloy	Male	US English
echo	am_echo	Male	US English
fable	bm_fable	Male	British
nova	af_nova	Female	US English
onyx	am_onyx	Male	US English
shimmer	bf_lily	Female	British

Beyond these, Kokoro has voices OpenAI doesn't offer. af_heart is a warm female voice that works well for meditation apps. am_fenrir has a deeper tone suited for trailers and dramatic narration. Spanish, French, Hindi, Italian, and Brazilian Portuguese each have dedicated native speakers — not the same English voice attempting another language.

Output formats

Kokoro supports mp3, wav, flac, and opus. Pass the format through the OpenAI SDK's response_format parameter:

audio = client.audio.speech.create(
    model="Kokoro",
    voice="am_adam",
    input="Testing FLAC output at 24kHz sample rate.",
    response_format="flac"
)

All output runs at 24kHz sample rate — production quality for podcasts and audiobooks.

Going further: Qwen3 TTS

Kokoro handles most developer use cases out of the box. But deAPI also runs Qwen3 TTS, which adds voice cloning and voice design on top.

Voice cloning takes a 10-second audio sample and reproduces that speaker on any text you send. Record once in English, and the cloned voice carries over to nine other languages with the same timbre and pacing.

Voice design works the other way around. Describe what you want in plain text — "British male, 70s, warm baritone, documentary narrator energy" — and the model builds a matching speaker from scratch. Useful for prototyping characters or brand voices before hiring talent.

All three modes run through deAPI's native TTS endpoint. Here's a voice design example:

import requests
import time

API_KEY = "dpn-sk-your-key-here"
BASE = "https://api.deapi.ai/api/v1/client"
HEADERS = {"Authorization": f"Bearer {API_KEY}", "Accept": "application/json"}

response = requests.post(f"{BASE}/txt2audio", headers=HEADERS, data={
    "text": "And here, deep in the rainforest, we find a creature unlike any other.",
    "model": "Qwen3_TTS_12Hz_1_7B_VoiceDesign",
    "mode": "voice_design",
    "lang": "English",
    "speed": 1.0,
    "format": "mp3",
    "sample_rate": 24000,
    "instruct": "British male, 70s, warm baritone, measured pace, documentary narrator."
})

request_id = response.json()["data"]["request_id"]

while True:
    result = requests.get(
        f"{BASE}/request-status/{request_id}", headers=HEADERS
    ).json()
    if result["data"]["status"] == "done":
        print(f"Audio: {result['data']['result_url']}")
        break
    if result["data"]["status"] == "error":
        print(f"Error: {result['data']}")
        break
    time.sleep(1)

Qwen3 TTS costs $12.86 per million characters — still cheaper than OpenAI, and it gives you voice cloning that OpenAI doesn't offer at any price.

What it costs

Provider	Price per 1M chars	Voice cloning	Voice design
OpenAI tts-1	$15.00	No	No
OpenAI tts-1-hd	$30.00	No	No
deAPI Kokoro	$0.77	No	No
deAPI Qwen3 TTS	$12.86	Yes	Yes

The $5 free credit on deAPI signup covers about 6.5 million characters through Kokoro. For context, the entire Harry Potter series is roughly 6.1 million characters. You could generate the full audiobook before spending a cent of your own money.

Full working script

Here's a complete, copy-paste script that generates speech and saves it to disk:

from openai import OpenAI
from pathlib import Path

client = OpenAI(
    api_key="dpn-sk-your-key-here",
    base_url="https://oai.deapi.ai/v1"
)

text = """
Three things happened this week that changed how I think about voice AI.
First, the cost dropped. Again. Second, the quality caught up with the
premium providers. And third, I realized I'd been overthinking this.
"""

audio = client.audio.speech.create(
    model="Kokoro",
    voice="af_nova",
    input=text.strip(),
    response_format="mp3"
)

output = Path("speech_output.mp3")
output.write_bytes(audio.content)

chars = len(text.strip())
cost = chars * 0.77 / 1_000_000
print(f"Saved to {output}")
print(f"Characters: {chars}")
print(f"Estimated cost: ${cost:.6f}")

Run it:

pip install openai
python tts_demo.py

What's next

Full API docs — docs.deapi.ai — all TTS endpoints, parameters, and language codes
Playground — app.deapi.ai/dashboard — test voices in the browser before writing code
OpenAI compatibility guide — docs.deapi.ai/openai-compatibility — migration details for image gen, transcription, and embeddings alongside TTS

The OpenAI SDK compatibility means you can swap one endpoint at a time. TTS first, then transcription or image generation whenever you're ready — same api_key, same base_url.

Built with deAPI — open-source AI models, decentralized GPUs, $5 free credits to start.

How to Generate Images with Flux API in Python

deAPI — Fri, 29 May 2026 11:12:14 +0000

Flux, built by Black Forest Labs, has become the go-to open-source model for image generation. This tutorial walks you through generating your first image with the Flux API using Python — from API key to saved file in under 5 minutes.

We'll use deAPI, which runs Flux models on decentralized GPUs and exposes an OpenAI-compatible endpoint. If you've ever used the OpenAI SDK, you already know 90% of what you need.

Prerequisites

Python 3.8+
The OpenAI Python package and requests (pip install openai requests)
A deAPI account (sign up at app.deapi.ai/dashboard — $5 free credits, no card required)

Step 1: Get your API key

Head to app.deapi.ai/dashboard and create an account. Your API key lives under Settings > API Keys. It starts with dpn-sk- — copy it and keep it safe.

Step 2: Generate your first image

Because deAPI is OpenAI-compatible, you use the standard openai Python package. The only thing that really changes is base_url — point it at deAPI and pass your deAPI key.

from openai import OpenAI

client = OpenAI(
    api_key="dpn-sk-your-key-here",
    base_url="https://oai.deapi.ai/v1"
)

response = client.images.generate(
    model="Flux1schnell",
    prompt="A neon-lit Tokyo alley at midnight, rain reflections on asphalt, cinematic photography",
    size="1024x1024",
    n=1
)

print(response.data[0].url)

That's it. Run the script, and you'll get back a URL pointing to your generated image.

Step 3: Save the image to disk

Most use cases need the actual file, not just a URL. Here's a complete script that generates and saves:

import requests
from openai import OpenAI

client = OpenAI(
    api_key="dpn-sk-your-key-here",
    base_url="https://oai.deapi.ai/v1"
)

response = client.images.generate(
    model="Flux1schnell",
    prompt="A neon-lit Tokyo alley at midnight, rain reflections on asphalt, cinematic photography",
    size="1024x1024",
    n=1
)

image_url = response.data[0].url
image_response = requests.get(image_url)
image_response.raise_for_status()

with open("generated_image.png", "wb") as f:
    f.write(image_response.content)

print(f"Image saved! URL: {image_url}")

Tweaking your generations

Resolution. For FLUX.1 Schnell the size parameter accepts values from 256×256 up to 2048×2048 in 128px increments. Smaller sizes are faster and cheaper — start with 768×768 for quick iterations.

Prompting tips. Flux responds well to specific visual language. Instead of "a beautiful sunset," try "golden hour over Santorini, whitewashed buildings, warm film grain, shot on 35mm." Lighting descriptions and camera terms give the model something concrete to work with.

Batch generation. Set n=2 or n=4 to generate multiple variations in a single call. Useful for exploring prompt directions before committing to a final version.

Flux models on deAPI

deAPI currently offers two Flux variants:

Model	Slug	Max resolution	Best for
FLUX.1 Schnell 12B NF4	`Flux1schnell`	2048×2048	Fast prototyping, iterations
FLUX.2 Klein 4B BF16	`Flux_2_Klein_4B_BF16`	1536×1536	Higher quality, also supports img2img

Switch between them by changing the model parameter. Everything else stays identical.

Next steps

Want to test prompts without writing code? The playground lets you experiment directly in the browser.

The full API reference lives at docs.deapi.ai.

This same OpenAI-compatible pattern works for text-to-speech, transcription, and video generation too — swap the model slug and endpoint, keep everything else.

Built with deAPI — open-source AI models, decentralized GPUs, $5 free credits to start.

How to Generate Images with Flux API in Python

deAPI — Thu, 28 May 2026 10:26:17 +0000

We'll use deAPI, which runs Flux models on decentralized GPUs and exposes an OpenAI-compatible endpoint. If you've ever used the OpenAI SDK, you already know 90% of what you need.

Prerequisites

Python 3.8+
The OpenAI Python package and requests (pip install openai requests)
A deAPI account (sign up at app.deapi.ai/dashboard — $5 free credits, no card required)

Step 1: Get your API key

Head to app.deapi.ai/dashboard and create an account. Your API key lives under Settings > API Keys. It starts with dpn-sk- — copy it and keep it safe.

Step 2: Generate your first image

Because deAPI is OpenAI-compatible, you use the standard openai Python package. The only thing that really changes is base_url — point it at deAPI and pass your deAPI key.

from openai import OpenAI

client = OpenAI(
    api_key="dpn-sk-your-key-here",
    base_url="https://oai.deapi.ai/v1"
)

response = client.images.generate(
    model="Flux1schnell",
    prompt="A neon-lit Tokyo alley at midnight, rain reflections on asphalt, cinematic photography",
    size="1024x1024",
    n=1
)

print(response.data[0].url)

That's it. Run the script, and you'll get back a URL pointing to your generated image.

Step 3: Save the image to disk

Most use cases need the actual file, not just a URL. Here's a complete script that generates and saves:

import requests
from openai import OpenAI

client = OpenAI(
    api_key="dpn-sk-your-key-here",
    base_url="https://oai.deapi.ai/v1"
)

response = client.images.generate(
    model="Flux1schnell",
    prompt="A neon-lit Tokyo alley at midnight, rain reflections on asphalt, cinematic photography",
    size="1024x1024",
    n=1
)

image_url = response.data[0].url
image_response = requests.get(image_url)
image_response.raise_for_status()

with open("generated_image.png", "wb") as f:
    f.write(image_response.content)

print(f"Image saved! URL: {image_url}")

Tweaking your generations

Batch generation. Set n=2 or n=4 to generate multiple variations in a single call. Useful for exploring prompt directions before committing to a final version.

Flux models on deAPI

deAPI currently offers two Flux variants:

Model	Slug	Max resolution	Best for
FLUX.1 Schnell 12B NF4	`Flux1schnell`	2048×2048	Fast prototyping, iterations
FLUX.2 Klein 4B BF16	`Flux_2_Klein_4B_BF16`	1536×1536	Higher quality, also supports img2img

Switch between them by changing the model parameter. Everything else stays identical.

Next steps

Want to test prompts without writing code? The playground lets you experiment directly in the browser.

The full API reference lives at docs.deapi.ai.

This same OpenAI-compatible pattern works for text-to-speech, transcription, and video generation too — swap the model slug and endpoint, keep everything else.

Built with deAPI — open-source AI models, decentralized GPUs, $5 free credits to start.