Generative Video 2026 — The Integration Landscape Across Closed APIs And Open Weights

Published 2026-06-01 · 28 min read · By Nikolay Sapunov, CEO at Fora Soft

Why This Matters

If you run a video product — an OTT platform that needs B-roll, a marketing tool that makes ads, a social app where users generate clips, an e-learning product that turns scripts into lessons — someone on your team has already asked "should we add AI video generation?" The honest answer in 2026 is that the models are good enough and cheap enough that the question is now a business decision, not a research bet. But the decision is full of traps: the prices look tiny per clip and then surprise you at volume, the "best" model on a leaderboard may be the wrong one for your latency budget, and the clip your model generates carries invisible labels and legal obligations you need to understand before a user hits publish. This lesson is written for the product manager, founder, or engineering lead who needs to make that call without a machine-learning background. It builds on the real-cost-of-AI lesson for the money math and the latency and deployment lesson for the cloud-versus-self-host trade-off; if the phrase "model weights" is new, the model-artifact-formats lesson defines it first.

What "Generative Video" Actually Means

Start with the plain-language version. A generative video model is a piece of AI software that produces a brand-new video clip from an instruction. The instruction is usually one of three things: a sentence of text ("a red fox trotting through snow at dawn"), a still image you want brought to life, or an existing clip you want changed. The model invents every frame; nothing is stitched together from a stock-footage library.

The everyday analogy is a very fast, very literal animator who has watched an enormous amount of video and can sketch a few seconds of new footage on demand. You describe the scene, the animator draws it frame by frame, and hands you a finished clip. The catch — and it shapes every engineering decision below — is that the animator is slow and works in a back room. You do not stand there watching them draw; you leave a request and come back when it is done. That single fact, which we will return to, is why integrating video generation is different from calling a normal web service.

Three terms recur, so define them once. Text-to-video, often shortened to T2V, means the instruction is words alone. Image-to-video, or I2V, means you give the model a starting still picture and it animates from there — useful when you need a specific product or face to appear. Video-to-video, or V2V, means you hand it existing footage and ask for an edit: change the lighting, swap the background, restyle the whole thing. Most 2026 models do all three, but they differ in which they do best, and that difference matters when you pick one.

One more piece of vocabulary, defined before we lean on it. Throughout this lesson, a model's weights are the giant table of numbers, learned during training, that holds everything the model knows. A closed model keeps its weights private on the vendor's servers — you send a request and rent the result. An open-weight model publishes that table so you can download it and run the model on your own hardware. That single distinction — rent the result, or own the machine — is the fork in the road this whole lesson is built around.

The Two Camps — And Why You Are Really Choosing Between Two Operating Models

The seven headline products in this lesson's title are all closed, rented-by-API models. A second camp of open-weight models sits beside them. They are not really competing on clip quality alone; they represent two different ways of running your business, with different costs, risks, and control. Get the camp right first, then pick a model inside it.

[Image: Landscape map of generative video in 2026. A horizontal axis runs left to right from 'Open weights — you run the machine' to 'Closed API — you rent the result'. A vertical axis runs bottom to top from 'Lower setup, less control' to 'More control, more responsibility'. On the closed-API side, seven labelled markers are grouped: 'Sora 2 / Sora 2 Pro (OpenAI)', 'Veo 3.1 (Google)', 'Kling 3.0 (Kuaishou)', 'Runway Gen-4 / Aleph', 'Pika 2.5', 'Luma Ray3', and 'Hailuo 02 (MiniMax)', each tagged with a one-line note such as 'native audio' or 'HDR output'. On the open-weights side, four markers are grouped in a box labelled 'download + self-host': 'Wan (Alibaba)', 'LTX-Video (Lightricks)', 'HunyuanVideo (Tencent)', and 'CogVideoX'. A vertical dashed divider separates the two camps, with a caption beneath: choose the camp before the model — it decides your cost shape, your data path, and who is responsible for the output.] Figure 1. The 2026 generative-video landscape, sorted by operating model. The fork is rent-versus-own, not brand-versus-brand. Pick the camp first.

Closed API — you rent the result. You send a prompt to a vendor's servers, they run their private model, and you get a finished clip back. You pay per second of video generated. You write no machine-learning code, you buy no graphics cards, and you get the newest, highest-quality models the day they ship. The price is that your prompts and outputs travel to a third party, your cost rises in lockstep with usage with no ceiling, and you are at the mercy of the vendor's rate limits, content filters, and roadmap. This is the right camp for most teams most of the time, especially early.

Open weights — you own the machine. You download the model's weights and run them on graphics cards you rent or own. Your prompts and footage never leave your infrastructure, which matters for sensitive content — medical, legal, unreleased product footage. Your cost is the fixed price of the hardware, so at very high volume it can undercut per-clip API pricing. The price is real: you need machine-learning operations skill, you need expensive graphics cards, the open models trail the best closed ones in quality by roughly a generation, and you carry the licensing burden yourself. This is the right camp for teams with scale, privacy requirements, or both — and it is the focus of the self-hosting open-weights lesson later in this phase.

The two questions to ask, in order: Does my content have to stay on my own servers? If yes, you are pushed toward open weights regardless of cost. Is my volume high enough that fixed hardware beats per-clip rental? If yes, open weights become cheaper past a crossover point we will compute below. If both answers are no — and for most products starting out they are — rent through a closed API and move on to building your product.

The Closed Models, In Plain Terms

Here is each of the seven rented models in the order a product team usually evaluates them. The numbers are current as of mid-2026; this is a fast-moving field, and every figure here is a snapshot you should re-verify before you commit budget.

Sora 2 (OpenAI)

Sora 2 is OpenAI's flagship video model and the most-searched name in this space. It generates clips with synchronized audio — dialogue, sound effects, ambient noise — in a single pass, from text or from a starting image. It comes in two tiers: standard Sora 2, which produces up to 720p and offers clip lengths of 4, 8, or 12 seconds, and Sora 2 Pro, which reaches true 1080p and offers longer 10-, 15-, and 25-second clips at noticeably higher cost.

Two integration facts matter more than the quality. First, OpenAI retired the standalone Sora consumer app in April 2026, so by mid-2026 Sora is something you reach through the API, not a website your users visit. Second — and this is the kind of detail that wrecks roadmaps — OpenAI announced that the Sora 2 API itself is scheduled to sunset on 24 September 2026, pushing developers toward a newer endpoint. The lesson is not the specific date; it is that closed-model APIs are versioned and retired on the vendor's schedule, and you must design your integration so that swapping the model behind it is a configuration change, not a rewrite.

Veo 3.1 (Google)

Veo 3.1, from Google DeepMind, is the model most teams already embedded in a Google-centric stack will reach for, because it is available through the same Gemini API and Vertex AI platform they already use. It generates native audio in a single pass and, after a January 2026 update, produces genuine 4K — rebuilding texture at the model level rather than upscaling a smaller frame. It ships in three tiers: a cheap Lite, a faster mid-tier Fast, and full-quality Veo 3.1, so you can trade quality for cost per request without changing vendors.

For a product team, Veo's advantage is integration gravity: if your backend already authenticates against Google Cloud, adding Veo is a smaller lift than onboarding a new vendor, with one bill and one set of credentials. Its audio-optional pricing — you pay more per second when you want sound — also lets you save money on clips that do not need it.

Kling 3.0 (Kuaishou)

Kling, from the Chinese company Kuaishou, has quietly become one of the strongest models on blind-preference leaderboards. By early 2026 it reached version 3.0, with clip lengths up to 15 seconds, 4K output, and — notably — multi-language native audio and multi-character dialogue with correct lip-sync. Kuaishou reports that over 60 million creators have generated more than 600 million videos with it, and the product reportedly crossed 300 million dollars in annual revenue, which tells you the model is battle-tested at scale, not a demo.

The thing to weigh for a Western product is operational: the vendor is based in China, which raises data-residency and procurement questions for some buyers, and access is often brokered through third-party API platforms rather than a first-party developer portal as polished as OpenAI's or Google's. The quality is genuinely top-tier; the integration path needs more diligence.

Runway (Gen-4 and Aleph)

Runway is the model built for people who edit video for a living, and it shows in what it is best at. Its 2026 lineup centers on the Gen-4 family for generation and Aleph, a video-to-video model that edits existing footage: relighting a scene, removing an object, changing an environment or style from a text instruction. That V2V strength is Runway's differentiator — if your use case is transforming footage you already have rather than conjuring clips from nothing, Runway is usually the first model to try.

Runway's pricing is unusually transparent for the category: a credit system where each second of Gen-4 Aleph costs a fixed number of credits, plus subscription plans that start around twelve to fifteen dollars a month and unlock the model family. It also exposes a clean developer API with per-second pricing around eighteen cents through partner platforms, which makes the cost math predictable — a real advantage when you are forecasting a budget.

Pika (2.5)

Pika, from Pika Labs, is the budget-friendly, fast-iteration option. Pika 2.5 generates clips up to 10 seconds at 1080p with synchronized audio and improved camera-motion control, at roughly twenty-eight cents per ten-second clip. It is not chasing the absolute quality crown; it is chasing speed and price for use cases where you generate many drafts — social content, concept proofs, A/B-tested ad variants — and only some make it to publish.

For a product team, Pika fits the "high volume, draft quality is fine" slot. If your workflow generates fifty candidate clips to pick three, paying a quarter each instead of several dollars each changes the economics of the whole feature.

Luma (Ray3)

Luma's Ray3, launched in late 2025, has one standout engineering feature: it was the first generative video model to produce native 16-bit high-dynamic-range output, exported in the EXR file format that professional color-grading pipelines accept directly. In plain terms, high dynamic range means a much wider span between the darkest and brightest parts of the picture — closer to what a film camera captures — and exporting it in EXR means a colorist can drop the AI clip straight into the same timeline as real footage without it looking flat. A January 2026 update added native 1080p and made the model cheaper and faster.

This makes Luma the model to reach for when AI clips have to sit next to professionally shot footage and survive a color grade — OTT post-production, premium advertising, film previsualization. For a plain social clip the HDR feature is wasted; for a broadcast pipeline it is the reason to pick Luma.

Hailuo 02 (MiniMax)

Hailuo, from the company MiniMax, is the value-for-quality standout of 2026. Hailuo 02 delivers 1080p clips with strong realism at around twenty-eight cents per video, and it ranks near the top of independent blind-preference benchmarks — in several 2026 evaluations beating models that cost several times more per clip. Its Pro tier runs at 24 to 30 frames per second for smoother cinematic motion.

For a product owner the appeal is blunt: it is one of the best quality-per-dollar options available, which makes it a strong default for consumer-facing features where you generate a lot of clips and margins matter. Like Kling, it is from a Chinese vendor, so the same data-residency diligence applies.

A Common Mistake: Choosing The Model At The Top Of The Leaderboard

Here is the pitfall that sinks more first integrations than any technical bug. A leaderboard ranks models by how often blind viewers prefer their clips. It does not rank them by how well they fit your product. The most-preferred model is frequently the slowest and most expensive, available only through a vendor whose data location you cannot use, or tuned for cinematic shots when your product needs fast social drafts.

The independent Artificial Analysis "Video Arena" — which ranks models by an Elo score from blind head-to-head votes, the same scoring system used for chess — is the fairest public quality yardstick in 2026, and it is worth reading precisely because it also lists each model's API price. In its mid-2026 text-to-video-with-audio standings, models from ByteDance and Alibaba topped the chart, with Google's Veo 3.1 and Kuaishou's Kling 3.0 leading the household names, and OpenAI's Sora 2 sitting mid-table despite its far larger search popularity. The takeaway is not "use the number-one model." It is "the popular name and the highest-quality model and the cheapest model are usually three different models — so decide which axis your product actually needs before you read the leaderboard."

The right selection order is: rule out by hard constraints first (data residency, maximum latency, maximum price per clip, the resolution and clip length you actually need), and only then rank the survivors by quality. A model you cannot legally use, or cannot afford at your volume, does not belong in the comparison no matter how good its clips look.

The Seven At A Glance

Put the closed models side by side and the right tool for a given job becomes obvious. The table below is the one to keep; the prices are mid-2026 snapshots and move often.

Table 1. The seven closed generative-video models of 2026. Match the "best at" column to your use case before you compare clip quality; the constraints in "watch out for" eliminate models faster than quality rankings do.

The One Integration Pattern Every Video API Forces On You

Here is the single most useful engineering fact in this lesson, and the part most "best AI video model" articles skip entirely. You cannot call a video API the way you call a normal web service — send a request, get an answer back in the same breath. Generating a clip takes anywhere from ten seconds to several minutes, far longer than a web request is allowed to wait. So every serious video API, closed or open, makes you use the same asynchronous pattern: you submit the job, you get a ticket back immediately, and you collect the finished clip later.

Think of it like a dry cleaner. You do not stand at the counter while they clean your coat; you hand it over, take a numbered ticket, and come back when it is ready. The video API works exactly like that. You send the prompt, it hands you a job identifier, and your code must then either keep asking "is it done yet?" at sensible intervals — called polling — or register a phone number the API calls when the clip is finished — called a webhook. Polling is simpler to build; webhooks are more efficient and the better choice at scale, because they do not waste requests asking a job that is not finished yet.

[Image: Diagram of the asynchronous generative-video integration pipeline. A left-to-right flow of six stages connected by arrows. Stage one, 'Submit', shows a user prompt entering a moderation gate labelled 'check the prompt BEFORE spending money'. Stage two, 'Queue', shows the job placed on an internal queue with a job ID returned instantly to the user. Stage three, 'Generate', tinted purple, shows the vendor API or self-hosted GPU rendering the clip, with two return paths labelled 'poll every 10-20s' and 'or webhook callback'. Stage four, 'Moderate output', shows the finished clip passing a second safety check. Stage five, 'Label', shows a C2PA content-credential manifest and SynthID watermark being attached. Stage six, 'Store + deliver', shows the clip saved to object storage and a URL returned to the product. A caption beneath reads: build this async pipeline on day one — submit, queue, poll or webhook, moderate, label, store. Retrofitting it later is a rewrite.] Figure 2. The asynchronous pipeline every video integration needs. The two safety gates — moderate the prompt before you pay, label the output before you deliver — are not optional in 2026.

Two gates in that pipeline are not optional, and skipping them is the second-most-common first-integration mistake after picking the wrong model. The first gate is moderate the prompt before you spend money: check the user's request against a safety filter before you dispatch the job, because once you submit it you have paid for it whether or not the result is usable or allowed. The second gate is label the output before you deliver it: attach the provenance information we cover below, because in several jurisdictions it is about to be legally required. Build both gates into the pipeline from the first version. Retrofitting safety and labeling into a pipeline that was not designed for them is a rewrite, and you will discover that the hard way the first time a user generates something you cannot ship.

The practical upshot for planning: a generative-video feature is not "one API call." It is a small back-end system — a queue, a job tracker, a moderation step, a labeling step, and object storage for the finished clips — wrapped around the API call. Budget for that infrastructure, not just the per-clip price. This is also why multi-vendor routing is worth designing early: because every closed API is versioned, rate-limited, and occasionally down, the teams that ship reliably put a thin internal layer in front of the vendor so they can fail over from one model to another, or swap a sunsetting model for its replacement, without touching the rest of the product.

What It Actually Costs — Do This Arithmetic Once

The prices look trivial per clip, which is exactly the trap. Let us do the math out loud, because the gap between "a few cents" and a real monthly bill is where budgets die.

The cleanest way to compare models is cost per minute of finished 1080p video, because that normalizes away the different clip lengths. From the Artificial Analysis price listing, a representative mid-2026 spread per minute of 1080p output looks like this: Sora 2 around six dollars, Veo 3.1 Fast around nine dollars, Kling 3.0 Pro around twenty dollars, Sora 2 Pro around thirty dollars, and the cheapest open-weight option, LTX-Video, around two and a half dollars. Hold those numbers loosely — they change monthly — but hold the ratios: the top-quality tiers cost five to ten times the budget tiers.

Now the arithmetic that every product owner should do once. Suppose your product lets users generate one eight-second clip each, you expect ten thousand generations a month, and you choose a mid-tier model at a blended rate of about ten cents per second of output.

cost per clip   = 8 seconds × $0.10 per second
                = $0.80

monthly cost    = 10,000 clips × $0.80
                = $8,000 per month

Eight thousand dollars a month for a feature that looked like "eighty cents a clip" in the demo. Now add the trap: video generation is iterative. Users rarely keep the first clip. If each kept clip takes, on average, three generations to get right, your real bill is three times the naive estimate:

real monthly cost = $8,000 × 3 (generations per kept clip)
                  = $24,000 per month

That is the number that should go in the plan — twenty-four thousand, not eight. The two levers that move it most are the model tier (a budget model at three cents per second cuts the bill by two-thirds) and the retry count (showing users a cheap, fast draft model first and only spending on the expensive model for the final render can halve the generations-per-kept-clip ratio). We work the full cost model, including how to set a hard spend ceiling so a runaway feature cannot bankrupt a launch, in the real-cost-of-AI lesson.

[Image: Bar chart comparing the real cost of a generative-video feature under three scenarios. The chart has a title 'What A Generative-Video Feature Really Costs Per Month' and a subtitle '10,000 eight-second clips, by model tier and retry assumption'. Four horizontal bars: the first, labelled 'Budget model, no retries (3 cents/sec)', reaches about $2,400, tinted green. The second, labelled 'Mid-tier, no retries (10 cents/sec)', reaches about $8,000, tinted blue. The third, labelled 'Mid-tier, 3 generations per kept clip', reaches about $24,000, tinted orange. The fourth, labelled 'Top tier, 3 generations per kept clip (30 cents/sec)', reaches about $72,000, tinted orange. Each bar prints its dollar value at the end. A caption beneath reads: the per-clip price is the smallest of the three multipliers — model tier and retries-per-kept-clip move the bill far more.] Figure 3. The same feature, four cost scenarios. The headline per-second price matters less than the model tier and the number of regenerations users need.

When Open Weights Win — The Crossover Math

Renting through an API is right until your volume gets large enough that fixed hardware is cheaper. Where is that crossover? Do the comparison the same way every time.

A rented graphics card capable of running a strong open-weight video model — an NVIDIA-class accelerator — costs on the order of one to two dollars an hour from a cloud provider in 2026. Suppose one such card can generate one minute of finished video in roughly five minutes of compute. That card produces about twelve minutes of video per hour, so its raw cost is around ten to twenty cents per minute of output, before you add the engineering salary to run it.

Compare that to renting Veo 3.1 Fast at roughly nine dollars per minute. On compute cost alone, self-hosting looks dramatically cheaper — but that comparison is a trap, because it ignores three real costs the API bundles in for free: the machine-learning engineers who keep the self-hosted system running, the idle time when your cards are powered on but not generating, and the quality gap, since the best open model trails the best closed model by roughly a generation. Factor those in and the honest crossover is not "always self-host because compute is cheap." It is: self-host when you have sustained high volume that keeps the cards busy, or a privacy requirement that forbids sending content to a third party, or both. Below that, the API's all-in convenience wins even though its sticker price per minute is higher. The full self-hosting build — which open models, which hardware, how to keep the cards busy — is the subject of the self-hosting open-weights lesson.

One licensing trap deserves a callout, because it is invisible until a lawyer finds it. Open weights are not automatically free for commercial use. The genuinely permissive licenses — Apache 2.0, which covers Wan, LTX-Video, and CogVideoX — allow full commercial use. But others carry conditions: Tencent's community license for HunyuanVideo, for example, permits commercial use but excludes certain regions including the European Union and the United Kingdom, and requires a separate license once a deploying company passes a user-count threshold. Read the license before you build on an open model, and read it again if your company operates in Europe — the model that is free for a startup in one country may be off-limits for the same startup in another.

Provenance And The Law: What Changes On 2 August 2026

This is the section that separates a feature you can ship from a feature that becomes a legal problem. Every clip your model generates can — and increasingly must — carry a label that says "this was made by AI." Two technologies do this, and in 2026 they are used together.

The first is C2PA Content Credentials. This is an industry standard — think of it as a tamper-evident sticker of metadata attached to the file — that records what tool made the content and how it was edited, signed cryptographically so it cannot be silently forged. The second is an invisible watermark, of which Google's SynthID is the best-known example: a pattern woven into the pixels themselves that survives screenshots and re-compression, so the label persists even when the metadata sticker is stripped off. The industry has converged on using both, because metadata can be removed and a pixel watermark cannot, easily.

By 2026 this is the default, not the exception. OpenAI signs every Sora 2 clip with a C2PA manifest plus a SynthID-style watermark; Google does the same across Veo and its other generators; Adobe, Microsoft, Stability AI, and others have followed. If you integrate one of these models, the labels are already on your output whether you asked for them or not — which means your pipeline must be designed to preserve them through any re-encoding or editing you do, not strip them.

[Image: Flow diagram of AI-content provenance and the EU AI Act Article 50 obligation. A finished AI clip on the left passes through two parallel labeling layers: an upper box labelled 'C2PA Content Credentials — a signed metadata manifest recording the tool and edits' and a lower box labelled 'Invisible watermark (SynthID-style) — a pattern in the pixels that survives screenshots'. Both feed into a central gate labelled 'EU AI Act Article 50 — in force 2 August 2026: providers and deployers must mark and disclose AI-generated or manipulated content'. From the gate an arrow leads to an outcome box: 'Disclosed clip — labels preserved through re-encoding and delivery'. A side note flags 'Strip the labels in your pipeline and you inherit the legal exposure.' A caption beneath reads: the two labels are complementary — metadata can be removed, the pixel watermark cannot easily; the law expects at least one to survive.] Figure 4. How provenance labeling meets the law. The clip carries two complementary labels; Article 50 turns "nice to have" into "required" across the EU from August 2026.

The legal driver is Article 50 of the European Union's AI Act, which takes effect on 2 August 2026. In plain terms, it requires that anyone who provides or deploys an AI system generating synthetic video, audio, or images must mark the output as artificially generated and disclose it to the people who see it. The European Commission's draft guidance points specifically at C2PA Content Credentials as an accepted way to satisfy the marking requirement, alongside watermarking. The practical consequence for a product team: if your product serves European users — and most products do — labeling AI-generated video is no longer a goodwill gesture, it is a compliance obligation with a deadline, and your integration must be built to honor it. We cover the full disclosure-engineering pattern, including how to surface the label to end users, in the quality, cost, and C2PA disclosure lesson.

The mistake to avoid is treating provenance as a feature you add later. The clips arrive labeled; your job is to not lose the label. Any step in your pipeline that re-encodes, crops, or restyles a clip can strip the C2PA manifest if you are not careful, leaving you delivering unlabeled AI video into a jurisdiction that requires labels. Design the pipeline so the label rides along to the end.

Where Fora Soft Fits In

We build video products across OTT and Internet TV, video conferencing, e-learning, telemedicine, surveillance, and AR/VR, and generative video now shows up in nearly all of them — automated B-roll and trailer generation for streaming platforms, synthetic training scenarios for e-learning, on-the-fly visual aids in conferencing. The work that separates a demo from a product is rarely the model call; it is the asynchronous pipeline, the cost ceiling, the multi-vendor failover, the moderation gates, and the provenance labeling that this lesson describes. We treat model choice as the easy, swappable part and the integration around it as the engineering. That posture — build the durable plumbing, keep the model behind a thin layer you can replace — is how a generative-video feature survives the next model release instead of being broken by it.

What To Read Next

• Closed-API integration — Sora, Runway, Kling, Pika, Luma recipes — the hands-on next step for the rent camp.
• Self-hosting open-weights — HunyuanVideo, CogVideoX, Mochi, LTX — the build for the own-the-machine camp.
• Quality, cost gates, C2PA and EU AI Act Article 50 disclosure engineering — how to ship compliant generative video.

Talk To Us / See Our Work / Download

• Talk to a video engineer — bring your use case and we will tell you which camp and which model fit, and what the pipeline costs to build.
• See our case studies — real video products we have shipped across OTT, conferencing, e-learning, telemedicine, and surveillance.
• Download the Generative Video Vendor Selection & Integration Checklist — a one-page decision aid covering camp choice, model shortlisting, the async pipeline, cost ceilings, and provenance compliance.

References

1. OpenAI. "Sora 2 Model" — model documentation: tiers, resolutions (720p / 1080p Pro), clip durations, per-second pricing. platform.openai.com/docs/models/sora-2. Accessed 2026-06-01.
2. OpenAI. "Advancing content provenance for a safer, more transparent AI ecosystem" — C2PA membership, SynthID watermarking, Sora 2 signing. openai.com/index/advancing-content-provenance/. Accessed 2026-06-01. (Primary/first-party.)
3. Google. "Veo 3.1" via Vertex AI / Gemini API documentation — tiers (Lite/Fast/Quality), native audio, 4K (Jan 2026 update), per-second pricing. cloud.google.com / ai.google.dev. Accessed 2026-06-01.
4. Kuaishou Technology. "Kling AI Launches 2.5 Turbo Video Model" (investor news release) and Kling 3.0 release notes — clip length, 4K, multilingual native audio, adoption figures. ir.kuaishou.com. Accessed 2026-06-01. (First-party vendor.)
5. Runway. "API Pricing & Costs" and "Introducing Runway Gen-4" — Gen-4 family, Aleph V2V, credit-based and per-second pricing. docs.dev.runwayml.com; runwayml.com/research. Accessed 2026-06-01. (First-party vendor.)
6. Artificial Analysis. "Text to Video Leaderboard" — Elo rankings from blind votes and per-minute API pricing for Sora 2, Veo 3.1, Kling 3.0, and open-weight LTX-Video; methodology. artificialanalysis.ai/video/leaderboard/text-to-video. Accessed 2026-06-01. (Independent benchmark — de-facto quality yardstick.)
7. C2PA. "Content Credentials" technical specification — signed manifest model for content provenance. c2pa.org/specifications. Accessed 2026-06-01. (Official standard.)
8. European Union. Regulation (EU) 2024/1689 (the AI Act), Article 50 — transparency obligations for AI-generated and manipulated content, in force 2 August 2026; European Commission draft Code of Practice on transparency citing C2PA. eur-lex.europa.eu. Accessed 2026-06-01. (Official regulation.)
9. Luma AI. Ray3 / Ray3.14 release notes — native 16-bit HDR, EXR export, 1080p update. lumalabs.ai. Accessed 2026-06-01.
10. MiniMax. Hailuo 02 documentation and independent benchmark coverage — 1080p, ~$0.28/clip, 24–30 fps Pro tier, Video Arena standing. Accessed 2026-06-01.
11. Pika Labs. Pika 2.5 release notes — 10s clips, 1080p, native audio, pricing. pika.art. Accessed 2026-06-01.
12. Alibaba / Tencent / Lightricks. Wan, HunyuanVideo (Tencent Community License), LTX-Video, and CogVideoX model cards and licenses — Apache 2.0 vs conditional commercial terms, region exclusions. Hugging Face model cards. Accessed 2026-06-01.