DEV Community: vvvvking

Your video, not our logo: how Seedance 2.0 API providers handle watermarks

vvvvking — Wed, 05 Aug 2026 15:09:31 +0000

The question nobody asks (but should)

You're building a product on top of a Chinese video API. Ad creative, e-commerce demos, short-form content for clients. You pick a Seedance 2.0 provider based on pricing, write the integration, test with a placeholder prompt.

Then you look at the output and there's a logo in the corner.

Not a subtle one. Not one you can ignore. A burned-in, visible watermark that says kie.ai or AI生成 and makes the clip unusable for any client-facing work.

This happened to us — except it happened on a competitor's output, not ours. So we tested.

What we tested

We run NovAI, an API gateway for Chinese AI models. We compared watermark behaviour across the major Seedance 2.0 API providers using three sources:

Direct API testing (for NovAI's own output): real call → MP4 download → frame extraction → OCR on corner crops → 4× zoom
Provider documentation analysis: does the API expose a watermark parameter? What's the default?
Third-party reports: Reddit threads, comparison blogs, user complaints

We checked this on 5 August 2026. Here's what we found.

The results

kie.ai: your video, their logo

kie.ai's API documentation includes a waterMark parameter with example value "kie.ai". Their Veo 3 landing page explicitly describes watermark addition. They also sell a "Sora Watermark Remover" tool on their own marketplace — which is a strange thing to sell when your API might be adding the watermark in the first place.

Third-party directory unifuncs.com labels kie.ai's watermark as "Yes (limited)."

Bottom line: kie.ai output may carry a platform watermark on top of whatever the model layer does. For client-facing work, this is a dealbreaker.

evolink.ai: clean output, professional caveats

evolink.ai is the only provider that explicitly commits to clean output in their FAQ: "Videos generated through the EvoLink API have no watermark and can be used commercially."

Their Chinese blog goes further, acknowledging that ByteDance embeds invisible provenance metadata (C2PA-style) at the model layer — and correctly stating that this is not a "watermark" in the visual sense. This is the most honest, professional treatment of the topic we've seen.

Bottom line: evolink claims clean visible output. They're a smaller provider with less public trust history, but their technical explanation is accurate.

atlascloud.ai: clean by default

Reddit tutorials in r/AtlasCloudAI show their API has a watermark parameter with default: false. No platform watermark unless you explicitly opt in.

NovAI: tested clean

We tested our own Seedance 2.0 output directly on 4 August 2026. Both Standard and Fast variants returned no visible label in video frames. Method: frame extraction → OCR → 4× visual zoom. Full per-model table with methodology: aiapi-pro.com/watermark-notice.

Image models are a different story — all five of our image models carry a visible AI生成 label. This is upstream ByteDance/Tencent/Zhipu behaviour that no provider can control.

fal.ai, replicate.com, wavespeed.ai, poyo.ai: silence

None of these providers publicly discuss watermarks. No documentation, no FAQ, no blog post. Silence = model default behaviour, which in ByteDance's case means no visible label on video.

But silence also means you're trusting without evidence. If the model layer changes behaviour (as it did with Tencent's Hunyuan Video), you won't know until you test.

Why this matters for your integration

The pattern across providers:

Situation	Visible watermark?
Seedance 2.0 video via API	❌ No (most providers)
Seedance 2.0 video via kie.ai	⚠️ Possible (platform parameter)
Seedance 2.0 video via evolink	❌ No (explicitly claimed)
Seedance 2.0 video via NovAI	❌ No (tested)
Seedance via Dreamina/CapCut (consumer)	✅ Yes (user complaints on Reddit)
All image models (any provider)	✅ Yes (upstream, not removable)

The "web version has watermark, API version is clean" distinction is real and important. If you've seen watermark complaints about Seedance on Reddit, those are about the consumer Dreamina/CapCut products — not the API. The API channels pass through clean output.

But kie.ai is the exception that proves the rule: they're adding a platform watermark on top of the model's clean output.

The invisible layer everyone shares

All providers face the same constraint: ByteDance embeds invisible provenance metadata at the model layer. This is not a visible watermark — it's metadata for traceability and compliance. No API provider can remove it, because it's embedded before the output leaves ByteDance's infrastructure.

Providers who say "no watermark" mean no visible label. Providers who say "no watermark and no invisible watermark" are either wrong or misleading.

evolink.ai handles this best: they promise clean visible output while acknowledging the invisible layer exists. That's the honest position.

Payment is the other watermark

There's a second barrier that gets less attention: payment methods.

Most Seedance 2.0 providers accept credit cards only. If you're in Southeast Asia, Latin America, the Middle East, or Africa, you may not have a Visa or Mastercard that works for international API payments.

Provider	Payment
NovAI	PayPal, USDT, debit card
fal.ai	Credit card (Stripe)
replicate.com	Credit card
OpenRouter	Credit card, USDC, Alipay
Others	Credit card (or unconfirmed)

NovAI is the only provider we've verified that accepts PayPal and USDT. This isn't a feature comparison — it's an access barrier. If PayPal is your payment method and you need Seedance 2.0, NovAI may be your only option.

What to do about it

Test before you commit. Every provider has a free tier or free credits. Generate 5 clips, download them, OCR the corners yourself. 10 minutes of work saves you weeks of integration pain.
Check the API docs for a watermark parameter. If the provider exposes one, check the default value. default: false is fine. default: "provider-name" is a red flag.
If you need PayPal/USDT, your options are limited. NovAI is the only confirmed provider. OpenRouter has USDC and Alipay but not PayPal yet.
Don't trust silence. If a provider doesn't discuss watermarks publicly, their output is probably clean (model default) but you have no guarantee. Test it yourself.

Try it

Dr 2 free credit on NovAI, no credit card required. Test Seedance 2.0 output quality and watermark behaviour yourself:

Watermark behaviour verified 4–5 August 2026. May change without notice. NovAI is an independent API gateway, not affiliated with ByteDance, kie.ai, evolink.ai, or any other provider listed. Full methodology and caveats on our watermark notice page.

We OCR'd every frame from 9 Chinese AI video models. 3 came back clean.

vvvvking — Tue, 04 Aug 2026 18:00:49 +0000

The assumption

Most developers I talk to assume that every Chinese AI model burns a visible AI生成 label into generated content. It's a reasonable assumption — China's labelling regulations (in force since September 2025) require it.

But "required" and "actually visible" turned out to be two different things. So we tested.

What we did

We run NovAI, an API gateway for Chinese AI models. We have 9 media generation models on the platform — 5 image, 4 video. For each one, we:

Made a real API call (same prompt for all: "A serene mountain landscape at golden hour, cinematic, high detail")
Downloaded the output
For video: extracted first, middle, and last frames with ffmpeg
Cropped the bottom-right corner (where labels typically appear)
Ran OCR on the crop
Zoomed 3–4× and re-inspected visually

No simulated output. No provider-supplied samples. Everything came from our own API endpoint.

What we found

Every image model has a visible label. All 5 of them. Paid or free, ByteDance/Tencent/Zhipu — doesn't matter. There's a AI生成 (or 图片由AI生成) stamp in the lower right.

Video models split by provider, not by price tier:

Model	Provider	Price	Visible label?
Seedance 2.0	ByteDance	$0.067–$1.00/s	❌ No
Seedance 2.0 Fast	ByteDance	$0.054–$0.802/s	❌ No
CogVideoX-Flash	Zhipu AI	Free forever	❌ No
Hunyuan Video 1.5	Tencent	$0.21/gen	✅ Yes

Three out of four video models came back clean. The pattern is provider × media type:

ByteDance: Labels images (Seedream), does not visibly label videos (Seedance)
Tencent: Labels both images and videos
Zhipu AI: Labels images (CogView), does not visibly label videos (CogVideoX)

Why this matters

If you're building a product on top of a Chinese video API — ad creative, e-commerce demos, short-form content — a burned-in corner label is a dealbreaker for client-facing output. Until now, the common assumption was that all Chinese models label everything. That assumption is wrong, and it's costing developers good options.

Seedance 2.0 at 720p costs ~$0.82 for a 5-second clip on our platform. It's a genuinely good model — cinematic motion, decent prompt adherence, 5-second duration. And in our tests, the frames are clean.

CogVideoX-Flash is free forever. 6-second clips. Also clean frames in our test.

Three honest caveats

I want to be careful here, because the internet has a way of stripping nuance:

1. "No visible label" ≠ "no labelling at all." Providers may still embed invisible metadata watermarks. CogVideoX's cover image, for example, is served through Zhipu's watermark pipeline even though nothing is visible in the video frames. We only report what we can see and OCR.

2. This is upstream behaviour, not ours. Providers can change how they apply labels at any time. If our next scheduled check finds a change, we'll update the watermark notice page.

3. Paying never removes an image label. All 5 image models carry the label regardless of whether they're paid or free. The pattern is provider × media type, not free vs paid.

Why providers differ

China's labelling rules require providers to attach labels to AI-generated content, but they don't specify the exact method. Each provider implements compliance differently:

ByteDance: Likely relies on metadata for video (no visible mark), but stamps images
Tencent: Stamps everything — images and videos both get a corner mark
Zhipu AI: Stamps images, leaves video frames clean (though the cover image goes through their watermark service)

This means the "safest" bet for visible-label-free video is currently ByteDance or Zhipu AI video models. But — caveat #2 — upstream behaviour can change.

The code

If you want to try Seedance 2.0 yourself:

import requests, time

BASE = "https://aiapi-pro.com/v1"
KEY = {"Authorization": "Bearer sk-novai-xxx"}

# Submit a Seedance 2.0 video task
task = requests.post(f"{BASE}/video/generations", headers=KEY, json={
    "model": "doubao-seedance-2.0",
    "prompt": "A drone shot over a neon city at night, cinematic",
    "duration": 5,
    "resolution": "720p",
}).json()

# Poll until done
while True:
    r = requests.get(f"{BASE}/video/generations/{task['id']}", headers=KEY).json()
    if r.get("status") not in ("queued", "processing"):
        break
    time.sleep(5)

print(r.get("content", {}).get("video_url") or r.get("content", {}).get("url"))

Or the free option, CogVideoX-Flash — same code, just change the model name:

task = requests.post(f"{BASE}/video/generations", headers=KEY, json={
    "model": "cogvideox-flash",
    "prompt": "A paper plane gliding over a calm ocean",
}).json()

$2 free credit on signup, no credit card. Register here if you want to test it.

The bigger picture

Most API gateways and relay services won't tell you which models have watermarks. They'll either say "no watermark" (often false) or say nothing at all. We think that's bad for everyone — developers waste time integrating models that don't work for their use case, and gateways lose trust when the output doesn't match the claim.

Our approach: test every model, publish the results with the method and date, and update it on a schedule. The watermark notice page has the full 9-model table, the three caveats, and a FAQ.

Tested, not guessed. That's the standard we're holding ourselves to.

Full per-model watermark table with methodology and FAQ: aiapi-pro.com/watermark-notice. NovAI is an independent API gateway, not affiliated with ByteDance, Tencent, or Zhipu AI.

Alibaba's Qwen3.8-Max: What 2.4 Trillion Parameters Actually Means for Developers

vvvvking — Mon, 03 Aug 2026 06:05:46 +0000

Disclosure: I run NovAI, an API gateway serving Qwen3.8-Max and 40+ other models. This is an analysis piece, not a product pitch — the technical observations below come from Alibaba's announcement and independent reviewers.

The parameter race is back (but it's different this time)

Remember 2024, when everyone was rushing to ship 400B models and the discourse was "parameters don't matter anymore, it's all about data quality"? That was true — for dense models. Then DeepSeek proved that MoE (mixture-of-experts) changes the math: you can have 671B total parameters but only activate 37B per token, getting dense-model quality at a fraction of the compute cost.

Now Alibaba has taken this to its logical extreme. Qwen3.8-Max-Preview, released 19 July at WAIC Shanghai, packs 2.4 trillion total parameters into a sparse MoE architecture. That's nearly 4x DeepSeek V3's total parameter count, and it puts Qwen in the same league as Kimi K3's 2.8T — the two largest models available via API today.

But here's what's actually interesting: it's not just bigger. It's the first Qwen model that's natively multimodal at this scale, and it's the first trillion-parameter model from a Chinese lab that independent reviewers say genuinely competes with Fable 5 and GPT-5.

What's genuinely new (not just "more parameters")

1. Native multimodality at 2.4T

Previous Qwen flagships (Qwen3-Max, Qwen3.7-Max) were text-only. Qwen3.8-Max processes text, images, video, and documents natively — no separate vision adapter, no "vision model" bolted on. This matters because:

You don't need to route different input types to different models
The model can reason across modalities (e.g., "read this PDF, look at this screenshot, and tell me if the UI matches the spec")
Document processing (PDF, HTML, Markdown) works without pre-processing to plain text

This is the real differentiator vs. Kimi K3, which is text + image only.

2. The self-verification behavior

An independent reviewer, Thomas Wiegold, ran Qwen3.8-Max through 4 coding benchmarks. His most interesting observation wasn't about quality — it was about process:

"It checked buttons, menus, animations and aspect ratios with Playwright like it was getting paid per test run."

The model doesn't just generate code and stop. It generates, then tests its own output using browser automation, then iterates. This is agentic behavior baked into the model's default response pattern. It's slow — a website build took 30+ minutes — but the output quality was described as "the best I've ever gotten from this prompt."

This is a meaningful shift. We're moving from "models that generate code" to "models that generate, test, debug, and iterate." The parameter count isn't what enables this — it's the training methodology. But 2.4T parameters give the model enough capacity to hold both generation and evaluation capabilities simultaneously.

3. OpenAI + Anthropic protocol support

This sounds boring, but it's actually a big deal. Qwen3.8-Max's API speaks both OpenAI and Anthropic protocols natively. That means:

Cursor users can swap in Qwen3.8-Max by changing one config line (OpenAI protocol)
Claude Code users can do the same (Anthropic protocol)
No wrapper, no adapter, no translation layer

Most Chinese models only speak OpenAI format. Supporting Anthropic protocol natively means Qwen3.8-Max can serve as a drop-in replacement for Claude in tools that only support the Anthropic API.

What's marketing (be honest)

"Second only to Fable 5"

Alibaba's claim. No benchmark table has been published. No model card exists. The only independent evaluation found (Trilogy AI's StackPerf) scored Qwen3.8-Max at 80 vs. Kimi K3's 83 — on a single task, single run. Take it as a data point, not a verdict.

The 2.4T number itself

Total parameters ≠ active parameters. In a sparse MoE model, only a fraction of parameters are activated per token. Alibaba hasn't disclosed the active parameter count. The model could be activating 50B, 100B, or 200B per token — and that's what determines actual inference cost and latency, not the total.

"Open weights coming soon"

Promised, with no date and no license. The previous Qwen3-Max was open-weighted; Qwen3.7-Max was not. Treat this as likely but uncertain. If open weights land, the small Qwen3.8 models (distilled from the flagship) will be the real story for local AI.

What it means for developers

For API consumers

Qwen3.8-Max is available through OpenAI-compatible gateways. If you're already using the OpenAI SDK:

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_KEY",
    base_url="https://aiapi-pro.com/v1",  # any OpenAI-compatible gateway
)

resp = client.chat.completions.create(
    model="qwen3.8-max",
    messages=[{"role": "user", "content": "Your prompt here"}],
)

That's it. Streaming, function calling, and multimodal input all work with standard OpenAI SDK patterns.

For the model landscape

The frontier is now genuinely crowded. Here's the honest state of play as of July 2026:

Model	Claim to fame	Weakness
Claude Fable 5	Best overall quality	Expensive, locked behind subscriptions
GPT-5	Best speed/quality balance	Closed, expensive
Kimi K3	2.8T params, 1M context	Text + image only
Qwen3.8-Max	2.4T, multimodal, cheap preview	Slow, preview-only, CCP guardrails
Grok 4.5	Fast, cheap, good coder	Smaller context, X-aligned guardrails

The real differentiators in 2026 aren't quality — the top 5 models are all "great" and "close." The differentiators are price, speed, availability, and guardrails. Qwen3.8-Max wins on price (preview at 1/10th standard rate) and loses on speed.

For local AI

Qwen is the open-weight family powering a huge chunk of local agent setups. If the promised open weights land, and if Qwen3.8's improvements trickle down to 7B–72B sizes, that's the real story. A 72B Qwen3.8 model with distilled multimodal capability, running on a consumer GPU, would be a game-changer for privacy-sensitive use cases (medical, legal, enterprise).

The honest take

Qwen3.8-Max is a genuinely impressive model that's being shipped as a preview with a lot of unanswered questions. The 2.4T parameter count is a headline, not a spec — what matters is the native multimodality, the self-verification behavior, and the protocol compatibility.

If you're choosing a model for rapid iteration, pick something faster (Grok 4.5, DeepSeek V4 Flash, Qwen-Plus). If you're choosing a model for thorough one-shot tasks — a full website build, a complex codebase audit, a deep research analysis — Qwen3.8-Max belongs in the top tier, and at preview pricing, it's the cheapest option there.

Try it with $2 free credit (no credit card) at NovAI, or through Alibaba's own Token Plan. Run your own prompts and judge for yourself — that's what the preview is for.

Full API guide with Python, Node, and curl examples: Qwen3.8-Max API Guide. NovAI is an independent API gateway, not affiliated with Alibaba Cloud.

Qwen3.8-Max: Calling Alibaba's 2.4T Flagship Through an OpenAI-Compatible API

vvvvking — Mon, 03 Aug 2026 05:47:26 +0000

Disclosure: I run NovAI, an API gateway that serves Qwen3.8-Max alongside 40+ other models. Specs below are from Alibaba's announcement; you can verify pricing yourself.

Alibaba's Qwen team released Qwen3.8-Max-Preview on 19 July 2026 at WAIC Shanghai: a 2.4-trillion-parameter sparse-MoE model, natively multimodal (text + images + video + documents), with a 128K context window (extendable to 1M). Alibaba called it "second only to Fable 5" â€” and early independent testing puts it in the top tier for coding and reasoning.

It's now available through an OpenAI-compatible endpoint. If you already use the OpenAI SDK, it's a two-line change.

TL;DR

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_KEY",
    base_url="https://aiapi-pro.com/v1",
)

resp = client.chat.completions.create(
    model="qwen3.8-max",
    messages=[{"role": "user", "content": "Explain sparse MoE routing in 3 bullet points."}],
)
print(resp.choices[0].message.content)

Streaming works exactly as you'd expect:

for chunk in client.chat.completions.create(
    model="qwen3.8-max",
    messages=[{"role": "user", "content": "Write a haiku about trillion-parameter models."}],
    stream=True,
):
    print(chunk.choices[0].delta.content or "", end="", flush=True)

Multimodal: images and documents

Qwen3.8-Max is natively multimodal â€” vision is built in, not bolted on. Send an image with the standard image_url content type:

resp = client.chat.completions.create(
    model="qwen3.8-max",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "What's in this screenshot? List all UI elements."},
            {"type": "image_url", "image_url": {"url": "https://example.com/ui.png"}},
        ],
    }],
)

It also accepts PDF, HTML, and Markdown directly â€” no pre-processing to plain text needed.

Why Qwen3.8-Max matters

Spec	Value
Total parameters	2.4T (sparse MoE)
Modality	Text, images, video, documents
Context window	128K standard (1M extended)
API protocol	OpenAI + Anthropic compatible
Open weights	Promised "soon" (no date yet)

An independent reviewer (Thomas Wiegold) ran it through 4 coding tests â€” including a full Go poker simulation that only Fable 5 and Grok 4.5 had previously one-shotted. Qwen3.8-Max became the third model to do it. His takeaway: "very good and very slow" â€” the model spends extensive time on self-verification, which trades speed for thoroughness.

Pricing

Alibaba's official rate for Qwen3.8-Max is Â¥12 / Â¥36 per million tokens (input / output) â€” roughly $1.67 / $5.00. During the preview period, Alibaba offers it at 1/10th of standard rate (Â¥1.2 / Â¥3.6, ~$0.17 / $0.50), with overnight rates as low as 1/50th (22:00â€“08:00 UTC+8).

NovAI passes these preview savings through. Check live per-token pricing: https://aiapi-pro.com/pricing

New keys come with $2 free credit, no credit card, so you can test Qwen3.8-Max against your own prompts before spending anything.

Try it

Copy-paste examples in Python, Node, and curl (chat, streaming, vision, long context) are on GitHub:

ðŸ‘‰ https://github.com/vvvvking/novai-examples

Full guide with curl + Node snippets and FAQ: Qwen3.8-Max API Guide. NovAI is an independent API gateway and is not affiliated with Alibaba Cloud.

I Ran 8 AI APIs Through the Same 50 Prompts — Here's the Real Cost Breakdown

vvvvking — Sun, 02 Aug 2026 14:03:26 +0000

Disclosure: I'm 于侃 (Yu Kan), the developer behind NovAI, an API gateway for Chinese AI models. Every number in this article was measured by running the test script below. I tested DeepSeek's official API separately to verify the gateway adds zero overhead. The test prompts and full results are open-sourced — links at the bottom.

Everyone publishing API pricing comparisons is either cherry-picking prompts or quoting the official pricing page without testing. I got tired of it, so I ran the same 50 real-world prompts through 8 different AI APIs and tracked every single token and every cent.

Here's what I actually found — including a few results that surprised me.

TL;DR

Rank	API	Cost (50 prompts)	Quality (1-5)
1	NovAI / Qwen-Plus	$0.011	3.9
2	NovAI / DeepSeek V4 Flash	$0.019	4.1
3	DeepSeek (official) V4 Flash	$0.019	4.1
4	Google Gemini 3.1 Flash	$0.027	3.8
5	NovAI / Doubao Seed 2.0 Lite	$0.034	3.7
6	OpenAI GPT-5	$0.142	4.6
7	OpenAI GPT-4o	$0.198	4.3
8	Anthropic Claude Sonnet 4.6	$0.287	4.7

The cheapest option was 26× cheaper than the most expensive one. The quality gap between #1 and #8 was 0.8 points on a 5-point scale.

What I tested

I used 50 prompts across 5 categories:

10 coding tasks (debug Python, write SQL, explain Rust errors)
10 reasoning tasks (math word problems, logic puzzles)
10 writing tasks (blog intros, email drafts, documentation)
10 multilingual tasks (English↔Chinese↔Japanese translation)
10 long-context tasks (summarize 8K-token documents)

For each prompt, I measured:

Input tokens (exact count from API response)
Output tokens (exact count)
Wall-clock latency (time to first token + total time)
Quality (manual review on a 1-5 scale)
Cost (calculated from official pricing, not marketing claims)

The 8 APIs I tested

Pricing verified July 2026 from official pricing pages. Prices change — always check the source.

API	Model used	Input $/1M	Output $/1M	Context
OpenAI	GPT-5	$1.25	$10.00	128K
OpenAI	GPT-4o	$2.50	$10.00	128K
Anthropic	Claude Sonnet 4.6	$3.00	$15.00	200K
Google	Gemini 3.1 Flash	$0.15	$0.60	1M
DeepSeek (official)	DeepSeek V4 Flash	$0.14	$0.28	128K
NovAI	DeepSeek V4 Flash	$0.14	$0.28	128K
NovAI	Qwen-Plus	$0.08	$0.32	128K
NovAI	Doubao Seed 2.0 Lite	$0.25	$0.80	256K

I tested both DeepSeek's official API and DeepSeek via NovAI to check whether the gateway adds overhead (spoiler: it doesn't — identical token counts, <50ms latency difference).

The results: total cost for all 50 prompts

Rank	API	Total cost (50 prompts)	Avg quality (1-5)
1	NovAI / Qwen-Plus	$0.011	3.9
2	NovAI / DeepSeek V4 Flash	$0.019	4.1
3	DeepSeek (official) V4 Flash	$0.019	4.1
4	Google Gemini 3.1 Flash	$0.027	3.8
5	NovAI / Doubao Seed 2.0 Lite	$0.034	3.7
6	OpenAI GPT-5	$0.142	4.6
7	OpenAI GPT-4o	$0.198	4.3
8	Anthropic Claude Sonnet 4.6	$0.287	4.7

The cheapest option was 26× cheaper than the most expensive one. And the quality difference between #1 (Qwen-Plus at $0.011) and #8 (Claude at $0.287) was 0.8 points on a 5-point scale.

What surprised me

1. Qwen-Plus is absurdly cheap and genuinely good.

At $0.08/1M input and $0.32/1M output, Qwen-Plus was the cheapest model I tested — and it scored 3.9/5 on quality, beating Gemini 3.1 Flash (3.8/5) which costs 2.4× more. For coding tasks specifically, it scored 4.2/5, matching DeepSeek V4 Flash.

2. DeepSeek via NovAI is identical to DeepSeek's official API.

I was skeptical that a gateway would add latency or modify token counts. I tested the exact same prompts through both. Result:

Token counts: identical (0% difference)
Latency: NovAI averaged 42ms slower (640ms vs 598ms for first token) — negligible
Cost: identical (same per-token pricing)

The gateway adds zero overhead. This matters because NovAI gives you access to 40+ Chinese models through one API key, while DeepSeek's official API only gives you DeepSeek.

3. The "quality gap" is smaller than pricing pages suggest.

Look at pricing tables and you'd think there's a massive quality difference between GPT-5 ($1.25/$10) and DeepSeek V4 Flash ($0.14/$0.28). In practice, for the 50 prompts I tested:

GPT-5 scored 4.6/5
DeepSeek V4 Flash scored 4.1/5
The gap is 0.5 points — noticeable but not "10× better"
The price gap is 10× on input, 36× on output

For 90% of production workloads (chatbots, content generation, code completion, document processing), the 0.5-point quality difference is invisible to end users. The 10-36× price difference is very visible to your CFO.

4. Claude is the best, but only marginally — and at a huge premium.

Claude Sonnet 4.6 scored 4.7/5 — the highest quality. But it cost $0.287 for 50 prompts vs $0.019 for DeepSeek V4 Flash (which scored 4.1/5). That's 15× more expensive for 0.6 points of quality. Claude makes sense for legal documents and medical summaries. For everything else, it's overkill.

Where each API actually wins

Use OpenAI GPT-5 when:

You need the absolute best reasoning quality
You're building a customer-facing product where quality is the differentiator
Your margins can absorb $1.25/$10 per million tokens

Use DeepSeek V4 Flash when:

You need GPT-4-level quality at 1/10th the price
You're doing coding tasks, reasoning, or general chat
You want the best price-to-quality ratio in 2026

Use Qwen-Plus when:

Cost is the #1 priority
You're doing multilingual work (especially Chinese/English)
You can tolerate slightly lower quality on complex reasoning

Use Claude Sonnet 4.6 when:

Quality is non-negotiable (legal, medical, compliance)
You're processing long documents (200K context)
Budget is not a constraint

The code I used to test

Here's the Python script I used. It's simple, reproducible, and you can run it yourself.

from openai import OpenAI
import time, json

# Test with NovAI (works identically with any OpenAI-compatible API)
client = OpenAI(
    base_url="https://aiapi-pro.com/v1",
    api_key="nvai-your-key-here"
)

prompts = [
    "Write a Python function to merge two sorted linked lists",
    "Explain the difference between mutex and semaphore",
    "Translate to Chinese: 'The quick brown fox jumps over the lazy dog'",
    # ... 47 more prompts (full list in the GitHub repo)
]

results = []
for prompt in prompts:
    start = time.time()
    response = client.chat.completions.create(
        model="deepseek-v4-flash",  # or qwen-plus, doubao-seed-2.0-lite
        messages=[{"role": "user", "content": prompt}],
    )
    latency = time.time() - start

    results.append({
        "prompt": prompt,
        "input_tokens": response.usage.prompt_tokens,
        "output_tokens": response.usage.completion_tokens,
        "latency_ms": round(latency * 1000),
        "response": response.choices[0].message.content,
    })

# Calculate cost
INPUT_PRICE = 0.14  # $/1M tokens for deepseek-v4-flash
OUTPUT_PRICE = 0.28

total_input = sum(r["input_tokens"] for r in results)
total_output = sum(r["output_tokens"] for r in results)
total_cost = (total_input * INPUT_PRICE + total_output * OUTPUT_PRICE) / 1_000_000

print(f"Total cost for {len(prompts)} prompts: ${total_cost:.4f}")
print(f"Avg latency: {sum(r['latency_ms'] for r in results)/len(results):.0f}ms")

You can swap the base_url and api_key to test any provider. The OpenAI Python SDK works with any OpenAI-compatible API — that's the beauty of the standard.

How to reproduce this yourself

If you want to verify these numbers (and you should — don't trust random blog posts), here's how:

Get API keys from each provider. OpenAI, Anthropic, Google, DeepSeek all offer free credits. For NovAI, you can register at aiapi-pro.com/register and get free credits — no credit card needed.
Run the same 50 prompts. I've open-sourced my test prompts and script at github.com/vvvvking/ai-api-cost-comparison.
Calculate costs using official pricing pages. Don't use my numbers — use the official pricing pages:
- OpenAI: developers.openai.com/api/docs/pricing
- DeepSeek: api-docs.deepseek.com/quick_start/pricing
- NovAI: aiapi-pro.com/blog/chinese-ai-api-pricing-2026

The honest caveats

50 prompts is a small sample. Your workload will differ. Run the test on your own prompts.
Quality scoring is subjective. I scored manually. You might disagree with my 4.1 vs 4.6 ratings. The point is the relative difference, not the absolute numbers.
I didn't test image/video generation. This is text-only. Image and video generation has completely different economics — and Chinese models have a mandatory AI生成 watermark that you should know about before using them. (Disclosure: I work on NovAI, which is a gateway for these models. The watermark is a legal requirement in China and cannot be removed. See aiapi-pro.com/watermark-notice.)
Latency varies by region. I tested from Southeast Asia. If you're in the US or Europe, add 50-150ms to all latency numbers. DeepSeek and NovAI have servers in Asia, so they're naturally faster for Asian users.
I work on NovAI. I've been transparent about this throughout the article. But the numbers are real and reproducible — I tested DeepSeek's official API separately and got identical results. The gateway overhead is negligible. Run the test yourself if you're skeptical.

The bottom line

If you're paying OpenAI prices for production workloads where GPT-4-level quality is sufficient, you're burning money. The math is simple:

GPT-5: $1.25/$10 per million tokens
DeepSeek V4 Flash: $0.14/$0.28 per million tokens
Same quality tier for 10-36× less money

For a typical SaaS app doing 1M input + 500K output tokens per day:

GPT-5: $6.25/day = $2,281/year
DeepSeek V4 Flash: $0.28/day = $102/year

That's $2,179/year in savings, for a model that scores 4.1/5 vs 4.6/5 on quality. For most apps, users won't notice the difference. Your CFO will notice the $2,179.

The code to switch is one line:

client = OpenAI(
    base_url="https://aiapi-pro.com/v1",  # was: https://api.openai.com/v1
    api_key="nvai-your-key-here"           # was: sk-your-openai-key
)

Test it yourself. The free credits are enough to run 50 prompts and verify every number in this article.

Disclosure: I'm 于侃 (Yu Kan), the developer behind NovAI (aiapi-pro.com). I wrote this article because I was frustrated by the lack of honest, reproducible API cost comparisons. Every number in this article was measured by running the test script above. The test prompts and full results are open-sourced at github.com/vvvvking/ai-api-cost-comparison. If you find an error, open an issue.

A genuinely free AI video + image generation API (no credit card) — with working Python code

vvvvking — Thu, 30 Jul 2026 02:47:55 +0000

Disclosure: I operate NovAI, the gateway described below. All prices are what our billing actually charges as of July 2026. This post was written with AI assistance and reviewed by me.

Most "free" video generation APIs are trial credits: you get $5–10, burn through it in a dozen clips, then hit a paywall that wants a credit card. While building our gateway I found that Zhipu's flash-tier models (cogvideox-flash for video, cogview-3-flash for images) are genuinely free upstream — but the free tier is only exposed on the China-domestic platform. Zhipu's international site (z.ai) only sells the paid models.

We route to the domestic endpoint, so both models are billed at $0 through our OpenAI-compatible API. Email signup, no card. Here's the working code.

Free image generation ($0/image)

It's a drop-in for the OpenAI SDK — just change base_url:

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_NOVAI_KEY",              # free key: https://aiapi-pro.com
    base_url="https://aiapi-pro.com/v1",
)

img = client.images.generate(
    model="cogview-3-flash",               # $0 / image
    prompt="isometric illustration of a tiny server room, pastel colors",
)
print(img.data[0].url)

Free video generation ($0/generation)

Video is asynchronous: submit a job, poll until it's done.

import requests, time

BASE = "https://aiapi-pro.com/v1"
H = {"Authorization": "Bearer YOUR_NOVAI_KEY", "Content-Type": "application/json"}

job = requests.post(f"{BASE}/video/generations", headers=H, json={
    "model": "cogvideox-flash",            # $0 / generation
    "prompt": "a paper plane gliding over a neon city at night",
}).json()

while True:
    r = requests.get(f"{BASE}/video/generations/{job['id']}",
                     headers=H, params={"model": "cogvideox-flash"}).json()
    if r.get("status") == "succeeded":
        print("video:", r["content"]["video_url"]); break
    if r.get("status") == "failed":
        raise RuntimeError(r)
    time.sleep(5)

Node.js and curl versions are in the novai-examples repo (MIT).

The honest part: what "flash tier" means

These are not frontier models. Being specific:

cogview-3-flash: solid for illustrations, thumbnails, placeholders. Noticeably below Seedream 5.0 / DALL·E-class output on photorealism and text rendering.
cogvideox-flash: short clips, lower fidelity than Seedance/Kling/Sora-class models. Good for prototyping a video pipeline, not for client deliverables.
Free-tier requests are queued at lower priority, so generation can be slower at peak times.

Where they shine: CI pipelines, hackathons, prototyping an async video flow, or any product where image cost must be exactly $0.

When you outgrow the free tier

Same API key and endpoint also serve paid Chinese models — for reference (our billing, July 2026):

Model	Type	Price
cogview-3-flash	image	$0
cogvideox-flash	video	$0
hy-image-lite	image	$0.014/image
doubao-seedream-5.0	image	$0.027/image
doubao-seedance-2.0	video	$0.329/s @1080p
hy-video-1.5	video	$0.21/generation

For comparison, fal.ai's published price for Seedance 2.0 at 1080p is roughly $0.68/s as of July 2026 (their pricing may change — check both before committing volume).

5 Free AI Models Through One OpenAI-Compatible API (Chat, Vision, Image Gen, Video Gen)

vvvvking — Sun, 26 Jul 2026 16:39:21 +0000

Disclosure: I run NovAI (aiapi-pro.com), the gateway described below. This is a first-party announcement, not an independent review.

We just made 5 models completely free on our OpenAI-compatible API — covering chat, vision reasoning, image generation and video generation. Here's what they are and how to call each one.

The 5 free models

Model ID	Type	Endpoint	Price
`glm-4.7-flash`	Chat LLM	`/v1/chat/completions`	$0
`glm-4.1v-thinking-flash`	Vision + reasoning	`/v1/chat/completions`	$0
`glm-4.6v-flash`	Vision	`/v1/chat/completions`	$0
`cogview-3-flash`	Image generation	`/v1/images/generations`	$0
`cogvideox-flash`	Video generation	`/v1/video/generations`	$0

All five are Zhipu (Z.ai) GLM-family "flash" variants. Zhipu offers them free upstream and we pass that through with zero markup. The trade-off is capability (flash models are smaller than flagships), not hidden fees.

Free chat: glm-4.7-flash

from openai import OpenAI

client = OpenAI(api_key="sk-novai-xxx", base_url="https://aiapi-pro.com/v1")

resp = client.chat.completions.create(
    model="glm-4.7-flash",
    messages=[{"role": "user", "content": "Summarize this in one sentence: ..."}],
)
print(resp.choices[0].message.content)

Free vision reasoning: glm-4.1v-thinking-flash

resp = client.chat.completions.create(
    model="glm-4.1v-thinking-flash",
    messages=[{"role": "user", "content": [
        {"type": "image_url", "image_url": {"url": "https://example.com/chart.png"}},
        {"type": "text", "text": "What trend does this chart show?"},
    ]}],
)

The "thinking" variant reasons step-by-step over images — charts, documents, screenshots. For plain image description, glm-4.6v-flash uses the same request format.

Free image generation: cogview-3-flash

img = client.images.generate(
    model="cogview-3-flash",
    prompt="minimalist logo of a paper plane, flat design",
)
print(img.data[0].url)

Free video generation: cogvideox-flash

import requests

r = requests.post(
    "https://aiapi-pro.com/v1/video/generations",
    headers={"Authorization": "Bearer sk-novai-xxx"},
    json={"model": "cogvideox-flash", "prompt": "a paper plane flying over a city at sunset"},
)
print(r.json())

Video generation is asynchronous — you get a task ID and poll for the result.

What are flash models actually good for?

Prototyping — build and demo an AI feature before spending anything
CI / integration tests — run pipeline tests against a real API at $0
Light production work — summaries, tagging, alt-text, thumbnails
Learning — try vision, image gen and video gen APIs without a budget

When you outgrow them, the same API key works for the paid catalog (DeepSeek, Qwen, Kimi, Doubao Seedance video, Seedream image, etc.).

FAQ

Do I need a Chinese phone number? No — email signup; paid models (if you ever need them) accept PayPal.

Is there a catch? No hidden fees. Flash models are just smaller than flagship models.

Questions about the free tier? Happy to answer in the comments.

ByteDance Seedance 2.0 video generation through an OpenAI-compatible API (Python)

vvvvking — Sun, 26 Jul 2026 15:09:55 +0000

Disclosure: I run NovAI, the API gateway used in the examples below. Everything shown works with a free $2 trial credit (no card required), and the same submit→poll pattern applies to any async video API.

TL;DR

Seedance 2.0 is ByteDance's video generation model. Unlike chat completions, video generation is asynchronous: you submit a job, get a task ID, then poll until the video is ready. Here's the whole flow in ~30 lines of Python:

import os, time, requests

BASE = "https://aiapi-pro.com/v1"
HEADERS = {
    "Authorization": f"Bearer {os.environ['NOVAI_API_KEY']}",
    "Content-Type": "application/json",
}

# 1) Submit the generation job
job = requests.post(
    f"{BASE}/video/generations",
    headers=HEADERS,
    json={
        "model": "doubao-seedance-2.0",
        "prompt": "a paper plane flying over a neon city at night, cinematic",
        "resolution": "720p",
        "duration": 5,
    },
).json()
task_id = job["id"]

# 2) Poll until ready
for _ in range(90):
    r = requests.get(
        f"{BASE}/video/generations/{task_id}",
        headers=HEADERS,
        params={"model": "doubao-seedance-2.0"},
    ).json()
    if r.get("status") == "succeeded":
        print("video URL:", r["video_url"])
        break
    time.sleep(5)

Swap model to doubao-seedance-2.0-fast when iteration speed matters more than fidelity.

Why async is the right shape for video

A 5-second 720p clip takes roughly 1–3 minutes to render. Holding an HTTP connection open that long is fragile (proxies time out, serverless functions hit limits). The submit→poll pattern means:

Your submit call returns in milliseconds
Polling is idempotent and retry-safe
You can fan out N jobs in parallel and poll them concurrently

# Fan-out: submit several prompts at once, poll them together
prompts = [
    "a lighthouse in a storm, drone shot",
    "ink-wash koi swimming through clouds",
    "timelapse of a city intersection at dusk",
]
task_ids = [
    requests.post(f"{BASE}/video/generations", headers=HEADERS,
                  json={"model": "doubao-seedance-2.0-fast", "prompt": p,
                        "resolution": "720p", "duration": 5}).json()["id"]
    for p in prompts
]

One endpoint, text + image + video

The same base_url and key also cover chat (DeepSeek, Qwen, GLM, Kimi) and image generation (Seedream 5.0), so a single integration handles a full multimodal pipeline — e.g. LLM writes the storyboard → Seedream renders keyframes → Seedance animates them. The public model list is at GET /v1/models if you want to see everything available (43 models at time of writing).

Runnable examples

Full scripts (submit, poll, download, plus image and chat variants):

GitHub: vvvvking/novai-examples — python/video.py is the file to start from
Docs: aiapi-pro.com/docs

Pricing is per generation and listed on the pricing page — I won't quote numbers here since they change; the $2 signup credit is enough to run several test clips.

Cross-posted from the NovAI blog. NovAI is not affiliated with ByteDance; Seedance is a trademark of its respective owner.

Kimi K3 API: Moonshot's 2.8T, 1M-Context Model via an OpenAI-Compatible Endpoint

vvvvking — Thu, 23 Jul 2026 11:31:01 +0000

Disclosure: I run NovAI, one of the API gateways that serves Kimi K3. Everything below (specs, pricing, code) is verifiable — specs are from Moonshot's announcement, and you can check pricing yourself.

Moonshot AI released Kimi K3 on 2026-07-16: a 2.8-trillion-parameter MoE, natively multimodal (text + vision), with a 1M-token context window, and open weights announced for July 27. It's the most interesting Chinese model drop of the summer — here's how to actually call it over an API today.

TL;DR

If you already use the OpenAI SDK, it's a two-line change:

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_KEY",
    base_url="https://aiapi-pro.com/v1",  # one gateway serving K3
)

resp = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Explain mixture-of-experts routing in 3 bullet points."}],
)
print(resp.choices[0].message.content)

Streaming works exactly as you'd expect:

for chunk in client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Write a haiku about long context."}],
    stream=True,
):
    print(chunk.choices[0].delta.content or "", end="", flush=True)

And because K3 is natively multimodal, vision input uses the standard image_url content type:

resp = client.chat.completions.create(
    model="kimi-k3",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "What's in this chart?"},
            {"type": "image_url", "image_url": {"url": "https://example.com/chart.png"}},
        ],
    }],
)

Why K3 matters

Per Moonshot's announcement:

2.8T total parameters (MoE) — the largest open-weights model announced to date
1M-token context — a full codebase or a stack of PDFs in one prompt
Native multimodality — vision is built in, not bolted on
Open weights — self-hostable once weights drop (announced July 27)

Pricing (honest numbers)

On NovAI, K3 is $2.90 / $14.50 per million tokens (input / output) for the 1M-context tier. For comparison, OpenRouter lists K3 at roughly $3.00 / $15.00 — so we're about 3% cheaper. That's parity, not a price war; the point of a gateway is one API surface across every major Chinese lab (DeepSeek, Qwen, GLM, Kimi, MiniMax, Doubao, Hunyuan) plus image and video generation.

Check current numbers yourself: https://aiapi-pro.com/pricing

Runnable examples

Copy-paste examples in Python, Node, and curl (chat, streaming, vision, long context) are on GitHub:

https://github.com/vvvvking/novai-examples

New keys come with $2 free credit, no credit card, so you can sanity-check K3 against your own prompts before spending anything.

Full guide with curl + Node snippets and FAQ: Kimi K3 API guide. NovAI is an independent API gateway and is not affiliated with Moonshot AI.

One OpenAI-compatible API for DeepSeek, Qwen, and Chinese image/video models

vvvvking — Mon, 20 Jul 2026 12:23:20 +0000

If you build with LLMs, you already have OpenAI-compatible code lying around. The nice thing about that format is you can point the same code at almost any provider by swapping base_url. What most guides skip is that the Chinese frontier models — DeepSeek, Qwen, Kimi, GLM, Doubao, MiniMax, Hunyuan — and their image and video siblings can be reached the exact same way.

This is a short, practical walkthrough of calling text, image, and video models from one OpenAI-compatible endpoint, with copy-paste code you can run in a minute. I'll use NovAI as the gateway (disclosure: it's the service I work on), but the patterns apply to any OpenAI-compatible endpoint.

Why one endpoint matters

If you want DeepSeek for reasoning, Qwen for multilingual, Seedream for images, and Seedance for short video, the naive path is four SDKs, four auth schemes, four billing dashboards. A single OpenAI-compatible gateway collapses that to one base_url + one key. Fewer moving parts, and your existing OpenAI code keeps working.

1. Chat — drop-in OpenAI SDK

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_KEY",
    base_url="https://aiapi-pro.com/v1",
)

resp = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[{"role": "user", "content": "Explain mixture-of-experts in one paragraph."}],
)
print(resp.choices[0].message.content)

Streaming is the standard stream=True iterator — nothing special. Swap model for qwen3.7-max, glm-5.2, kimi-k2.6, minimax-m3, doubao-seed-2.0-pro, etc.

2. Image — Doubao Seedream 5.0

Image generation follows the OpenAI images.generate shape:

img = client.images.generate(
    model="doubao-seedream-5.0",     # or -pro
    prompt="a red panda coding on a laptop, studio ghibli style, warm light",
    size="2048x2048",
    n=1,
)
print(img.data[0].url)

Seedream likes large sizes — go with 2048x2048 rather than the classic 1024x1024.

3. Video — Doubao Seedance 2.0 (async)

Video is the one place the flow differs: generation takes time, so you submit a job and poll.

import requests, time

BASE = "https://aiapi-pro.com/v1"
H = {"Authorization": "Bearer YOUR_KEY", "Content-Type": "application/json"}

job = requests.post(f"{BASE}/video/generations", headers=H, json={
    "model": "doubao-seedance-2.0",          # or -fast
    "prompt": "a paper plane flying over a neon city at night, cinematic",
    "resolution": "720p",
    "duration": 5,
}).json()

task_id = job["id"]
while True:
    r = requests.get(f"{BASE}/video/generations/{task_id}",
                     headers=H, params={"model": "doubao-seedance-2.0"}).json()
    if r.get("status") == "succeeded":
        print("video:", r["content"]["video_url"])
        break
    if r.get("status") == "failed":
        raise RuntimeError(r)
    time.sleep(4)

That's the whole surface: chat, image, video, same key.

A note on pricing (the honest version)

I won't pretend a gateway is magically cheapest across the board — that's rarely true and easy to disprove. From the current published numbers, some models come out clearly ahead of other aggregators (Qwen3.7-Max lands ~45% cheaper, Doubao-Seed-2.0-Lite ~53% cheaper than OpenRouter), some are effectively at parity (DeepSeek-V4-Pro), and a few are more expensive. The real win here isn't a price war — it's one API for text + image + video across every major Chinese lab, which the text-only aggregators don't cover. Always check live numbers before you commit.

Try it

Live playground (no signup needed to poke around): https://aiapi-pro.com/playground
Runnable examples (Python / Node / curl), MIT-licensed: https://github.com/vvvvking/novai-examples
New keys get $2 in free credit, no credit card: https://aiapi-pro.com

If you're already writing OpenAI-compatible code, adding Chinese text/image/video models is a base_url change away. Happy building.

Disclosure: I work on NovAI, the gateway used in the examples. Written with AI assistance for drafting; all code was verified against the live API.

DEV Community: vvvvking

Your video, not our logo: how Seedance 2.0 API providers handle watermarks

The question nobody asks (but should)

What we tested

The results

kie.ai: your video, their logo

evolink.ai: clean output, professional caveats

atlascloud.ai: clean by default

NovAI: tested clean

fal.ai, replicate.com, wavespeed.ai, poyo.ai: silence

Why this matters for your integration

The invisible layer everyone shares

Payment is the other watermark

What to do about it

Try it

We OCR'd every frame from 9 Chinese AI video models. 3 came back clean.

The assumption

What we did

What we found

Why this matters

Three honest caveats

Why providers differ

The code

The bigger picture

Alibaba's Qwen3.8-Max: What 2.4 Trillion Parameters Actually Means for Developers

The parameter race is back (but it's different this time)

What's genuinely new (not just "more parameters")

1. Native multimodality at 2.4T

2. The self-verification behavior

3. OpenAI + Anthropic protocol support

What's marketing (be honest)

"Second only to Fable 5"

The 2.4T number itself

"Open weights coming soon"

What it means for developers

For API consumers

For the model landscape

For local AI

The honest take

Qwen3.8-Max: Calling Alibaba's 2.4T Flagship Through an OpenAI-Compatible API

TL;DR

Multimodal: images and documents

Why Qwen3.8-Max matters

Pricing

Try it

I Ran 8 AI APIs Through the Same 50 Prompts — Here's the Real Cost Breakdown

TL;DR

What I tested

The 8 APIs I tested

The results: total cost for all 50 prompts

What surprised me

Where each API actually wins

The code I used to test

How to reproduce this yourself

The honest caveats

The bottom line

A genuinely free AI video + image generation API (no credit card) — with working Python code

Free image generation ($0/image)

Free video generation ($0/generation)

The honest part: what "flash tier" means

When you outgrow the free tier

Links

5 Free AI Models Through One OpenAI-Compatible API (Chat, Vision, Image Gen, Video Gen)

The 5 free models

Free chat: glm-4.7-flash

Free vision reasoning: glm-4.1v-thinking-flash

Free image generation: cogview-3-flash

Free video generation: cogvideox-flash

What are flash models actually good for?

FAQ

ByteDance Seedance 2.0 video generation through an OpenAI-compatible API (Python)

TL;DR

Why async is the right shape for video

One endpoint, text + image + video

Runnable examples

Kimi K3 API: Moonshot's 2.8T, 1M-Context Model via an OpenAI-Compatible Endpoint

TL;DR

Why K3 matters

Pricing (honest numbers)

Runnable examples