Kling O1 API: Integration Guide, Pricing & Code

“Kling O1” is not one endpoint, and that gap between the model and the API is where integration time goes. Kuaishou ships O1 as a single unified multimodal system — it reads a text prompt, first and last frames, reference images, a reference clip and library elements inside one request — but you cannot call it as a single thing. On Kuaishou’s own platform it is two routes: an omni video endpoint and an omni image endpoint. On Modellix it is four model IDs, each with its own input set, its own field list and its own rate. Search for a Kling O1 API reference today and you land on a video page, a separate element-management page, an image page, and a scatter of aggregator listings that carry the model name without the parameter table behind it.

This guide assembles the parts as they stood on September 10, 2026: which O1 model IDs exist and who exposes them, what each one costs per second or per image on that date, runnable submit-and-poll code for both the direct and aggregated routes, and — the section that saves the most debugging time — the O1-specific parameter constraints that return a 400 instead of a video. Two disclosures first. Modellix publishes this blog and sells the aggregated route described in the fifth section, so we have a commercial interest in one of the two paths; every Kuaishou figure below carries its own page and read date. Second, the near-synonym you may have typed — kling video o1 api — resolves to the same model as kling o1 api. There is no separate video-only SKU, so this page covers both instead of splitting them into two competing articles. If you want the wider map of Kuaishou’s developer surface before the O1 detail, our Kling API documentation guide covers the whole family; this page is the O1-specific deep dive.

What the Kling O1 API actually is: one reasoning model, four endpoints

Kling O1 is Kuaishou’s reasoning-enhanced multimodal model. The company describes it as the first unified multimodal video model, built on a “Multi-modal Visual Language” concept: rather than one task per call, you write the task in natural language and mix input types — prompt text, a first frame, a last frame, reference images, a source clip — in the same request. Its sibling, kling-image-o1, applies the same reasoning treatment to images, including multi-image combinations. Kuaishou’s own user guide for the video model carries a publication date of December 15, 2025, which is the earliest first-party date we could verify for the line — worth knowing because a lot of coverage treats O1 as the newest Kling model, when it is in fact a parallel track running alongside the 2.x and 3.0 generations rather than above them.

The functional difference from the 3.0 line is planning, and it is worth being precise about where that claim comes from. The phrase “performs deep planning over the prompt before generation” is Modellix’s own model-card wording for this route, not a Kuaishou quote — the vendor-neutral version of the same idea is Kuaishou’s Multi-modal Visual Language framing, in which diverse video tasks are integrated into a single unified architecture so that images, video, elements and text are understood together in one request. The practical consequence is the same either way: O1 is the model you reach for when a standard video model hallucinates the physics — liquid spilling, objects colliding, a sequence of actions that has to stay logically ordered. It is not the model you reach for when you want the longest clip or native audio; those are 3.0 and 3.0 Omni territory.

Concept diagram: O1 resolves the prompt into an internal plan before rendering frames. Generated for this article; it is not a screenshot of Kuaishou’s console.

That single model surfaces as four callable IDs on Modellix and two documented endpoints on Kuaishou’s platform. The mapping is not one-to-one, and it is the reason a copy-pasted request body from an aggregator page often fails against the official route:

What you are asking for	Modellix model ID	Kuaishou endpoint and input type
Video from text only	kling/kling-video-o1-t2v	POST /omni-video/kling-o1 — contents carries a prompt item only
Video from one to seven images	kling/kling-video-o1-i2v	Same route — first_frame / last_frame / refer_image items
Video restyled, edited or extended from a source clip	kling/kling-video-o1	Same route — base_video / feature_video items
Reasoning image generation and multi-image fusion	kling/kling-image-o1	POST /v1/images/omni-image with model_name: "kling-image-o1"

Because every host renames the model, here is the same request expressed as each platform’s identifier — the table almost nobody publishes, and the reason swapping providers usually means touching code:

Host	The identifier you actually send
Modellix	kling/kling-video-o1-t2v, kling/kling-video-o1-i2v, kling/kling-video-o1, kling/kling-image-o1
Kuaishou direct	No model field on the video route — the path is the model (/omni-video/kling-o1); the image route takes model_name: "kling-image-o1"
Leonardo	kling-video-o-1 (note the hyphen before the digit, and guidances for the frame/reference fields)
AI/ML API	kling-video/o1/video-to-video/reference — the path segment encodes the input set as well as the model
OpenRouter	kwaivgi/kling-video-o1
Replicate	kwaivgi/kling-o1

Read that table before you copy a snippet from anywhere: a body that works on one host will fail on another if the identifier does not match, and the mismatch is a 404, not a warning.

Two naming traps have already cost readers, and they point in opposite directions. The “O1” label refers to the reasoning track and appears on both the video and image sides — it is a track, not a generation tier. The “O3” label is the reverse problem: it is not the name Kuaishou’s own documentation and pricing pages use. Kuaishou writes Kling 3.0 Omni, and this platform lists the same models as kling-v3-omni-*; “O3” is the shorthand aggregators market them under, and at least one vendor says so on its own page — WaveSpeedAI’s O3 write-up states that “Kling O3 (also marketed as Kling 3.0 Omni)” is Kuaishou’s unified multimodal video model. So when you see an “O3” listing next to “O1”, you are looking at the 3.0 Omni line: a different track, not a newer version of O1. We covered the O1-versus-3.0 boundary in our Kling vs Runway comparison and will not repeat it here. Separately, Kuaishou’s Kling VIDEO O1 user guide — published December 15, 2025 — is the page that explains how the prompt syntax is meant to be written: how to reference an input (@image_1, <<<image_1>>>), how multi-subject fusion is expressed, and which task combinations can be stacked into one request. The API reference gives you the fields; that guide gives you the grammar.

Kling O1 API pricing, read September 10, 2026

Two billing models sit under the same model name, and they are not directly comparable until you convert Kuaishou’s units into dollars. Modellix meters in dollars per second of output (or per image); Kuaishou meters in prepaid units, where a video unit lists at $0.14 and an image unit at $0.0035.

On Modellix, the rates below were read from the four model pages on September 10, 2026 — for example the Kling Video O1 T2V model page, which shows a rate for each resolution rather than a single headline number:

Model ID	Billing unit	720p	1080p
kling/kling-video-o1-t2v	per second of output	$0.0672/s	$0.0896/s
kling/kling-video-o1-i2v	per second of output	$0.0672/s	$0.0896/s
kling/kling-video-o1 (reference video)	per second of output	$0.1008/s	$0.1344/s
kling/kling-image-o1	per image	$0.0224 (1K or 2K)	—

On Kuaishou’s own developer platform, the same date, official pricing page: the video API lists one unit at $0.14, sold as prepaid packages — 5,000 units for $700 with 180-day validity, larger tiers discounted to $0.126 per unit — and the image API lists one unit at $0.0035. Kling Image O1 appears in the image table at 8 units, or $0.028 per image, at 1K and 2K. For how the rest of the family is priced — the 2.x generations, 3.0, 3.0 Turbo and 3.0 Omni — our Kling API pricing breakdown by model version tracks the same per-second grid.

The honest gap: Kuaishou’s public video price tables do not contain a Kling O1 row as of September 10, 2026. Its flagship table covers Kling 3.0 Turbo, 3.0 and 3.0 Omni; the “Other Models” table covers Motion Control and Avatar. O1 is documented in the API reference and priced somewhere in the unit system, but the per-second list rate is not published on the pricing page. We are not going to invent one, and any page quoting a single confident “Kling O1 API price per second” from that page is filling a blank. If you need Kuaishou’s own O1 rate, the reliable way to get it is empirical: submit one short task, then read what was actually deducted.

What that works out to in real clips, using the Modellix rates:

• A 5-second 720p text-to-video clip: $0.336.
• A 10-second 1080p image-to-video clip, the model’s maximum: $0.896.
• Restyling a 5-second 1080p source clip through the reference-video route: $0.672.
• Ten reasoning image generations at 2K: $0.224.

Per minute of finished output, the 720p text-to-video route lands at $4.03 — and because O1’s ceiling is 10 seconds you reach that minute as six separate generations rather than one long take, so budget six requests, six poll cycles and six assets. A project figure follows from that: 60 ten-second 1080p clips is 600 seconds of output at about $53.76, before retakes. Retakes are the number that surprises teams, because O1 is chosen precisely for the shots that are hard to get right; multiply your first estimate accordingly.

Two properties matter more than the headline rate. O1 video has no 4K tier — 720p and 1080p are the whole grid, so your worst case is bounded in a way 3.0’s $0.42/s 4K cell is not. And audio does not change the bill on O1: unlike 3.0, where native audio adds 50%, O1’s audio field is not a paid upgrade, because on most O1 paths it is not an option at all.

Other hosts quote a single per-second number for this model and none of them normalise it, so here is the normalisation for the closest like-for-like task, the reference-video route: AI/ML API lists $0.1638/sec and Replicate quotes an estimated $0.168/sec. Both sit above the $0.1008/s this platform charges for comparable 720p work. Hosts differ in what they bundle and how they measure output, so read any single number as directional, and check the new-models changelog if you need to know whether an entry moved.

The exact Kling O1 model IDs, inputs, and parameters

Everything below was read from the four Modellix model pages on September 10, 2026. They are worth reading field by field rather than skimmed, because the constraints live in the parameter notes, not in a separate “limitations” section.

kling/kling-video-o1-t2v — text to video

Field	Required	Type	Default	Notes
prompt	yes	string	—	1–2500 characters
audio	no	enum	off	On this slice off is the only accepted value
resolution	no	enum	720p	720p or 1080p
aspect_ratio	no	enum	16:9	16:9, 9:16, 1:1
duration	no	integer	5	Any integer 3–10

kling/kling-video-o1-i2v — image to video

Same fields as above except: images is required and accepts 1–7 URLs or Base64 strings, and there is no aspect_ratio field at all — the output follows the first frame’s aspect ratio. With exactly one input image, duration must be 5 or 10; with more than one, any value from 3 to 10 is accepted.

kling/kling-video-o1 — reference video (restyle, edit, extend)

Field	Required	Type	Default	Notes
prompt	yes	string	—	1–2500 characters
videos	yes	string[]	—	Exactly one reference video
images	no	string[]	—	Up to 4 when a reference video is present
audio	no	enum	off	original or off; a feature video requires off
resolution	no	enum	720p	720p or 1080p
aspect_ratio	no	enum	16:9	Optional once a reference video is supplied
duration	no	integer	5	3–10, not further restricted by the reference video

kling/kling-image-o1 — reasoning image

Field	Required	Type	Default	Notes
prompt	yes	string	—	1–2500 characters; may reference inputs as <<<image_1>>>
images	no	string[]	—	1–10 when supplied; omit for pure text-to-image
resolution	no	enum	1k	1k or 2k on O1
aspect_ratio	no	enum	1:1	16:9, 9:16, 1:1, 4:3, 3:4, 3:2, 2:3, 21:9
n	no	integer	1	1–9 images per call

Each of those four tables is a digest of its own live reference page — kling-video-o1-t2v, kling-video-o1-i2v, kling-video-o1, kling-image-o1 — and those pages are the ones to trust if a default or an enum ever drifts from what is written here. Note the split: the docs pages carry the field definitions, while the billed rate lives on the corresponding model page, linked in the pricing section above.

Concept diagram: the four O1 request shapes. The input set, not the prompt wording, is what determines which model ID you call. Generated for this article.

If you are calling Kuaishou directly instead, the same four shapes collapse into two request bodies. The video route takes a contents array where each item declares a type — prompt, first_frame, last_frame, refer_image, feature_video, base_video or element — plus a settings object carrying resolution, duration, audio and aspect_ratio. The image route takes model_name: "kling-image-o1", a prompt, and its own image_list and element_list. The two official pages to bookmark are the Kling O1 video reference and the Kling Image O1 reference.

Making your first Kling O1 request: submit, poll, and read the result

Every Kling route is asynchronous, on both paths. You submit a task, you get an identifier back, you poll until the task reaches a terminal state, then you download the asset. The difference between the two paths is only the shape of the envelope.

Modellix — submit a text-to-video task. The endpoint is the model ID under the platform’s kling path:

curl --request POST \
  --url https://api.modellix.ai/api/v1/kling/kling-video-o1-t2v \
  --header 'Authorization: Bearer $MODELLIX_API_KEY' \
  --header 'Content-Type: application/json' \
  --data '{
    "prompt": "A glass of water tips over and spills across a wooden table, slow motion, shallow depth of field",
    "resolution": "1080p",
    "aspect_ratio": "16:9",
    "duration": 5
  }'

The response is a task handle rather than a video — code, message, and a data object carrying status: "pending", a task_id, and a get_result block that already contains the exact URL you should poll:

{
  "code": 0,
  "message": "success",
  "data": {
    "status": "pending",
    "task_id": "task-o1-t2v-123",
    "model_id": "model-123",
    "get_result": {
      "method": "GET",
      "url": "https://api.modellix.ai/api/v1/tasks/task-o1-t2v-123"
    }
  }
}

Poll it with that URL. The same request shape works for the other three O1 IDs — swap the path segment and the body fields.

Python — the polling loop, with backoff. The task result endpoint is documented at Query Task Result; what it does not give you is the loop, so here is one that handles the two retryable classes properly:

import os, time, requests

BASE = "https://api.modellix.ai/api/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['MODELLIX_API_KEY']}"}

def submit_o1(prompt, resolution="1080p", duration=5, model="kling-video-o1-t2v"):
    r = requests.post(
        f"{BASE}/kling/{model}",
        headers={**HEADERS, "Content-Type": "application/json"},
        json={"prompt": prompt, "resolution": resolution,
              "aspect_ratio": "16:9", "duration": duration},
        timeout=60,
    )
    if r.status_code == 429:
        reset = int(r.headers.get("X-RateLimit-Reset", 0))   # Unix timestamp, not a delay
        time.sleep(max(1, reset - int(time.time())) if reset else 60)
        return submit_o1(prompt, resolution, duration, model)
    r.raise_for_status()
    return r.json()["data"]["get_result"]["url"]

def wait_for_video(task_url, timeout=900):
    deadline, backoff = time.time() + timeout, 5
    while time.time() < deadline:
        q = requests.get(task_url, headers=HEADERS, timeout=60)
        if q.status_code in (500, 503):
            time.sleep(backoff); backoff = min(backoff * 2, 60); continue
        body = q.json()["data"]
        if body["status"] == "success":
            return body["result"]["resources"][0]["url"]
        if body["status"] in ("failed", "canceled"):
            raise RuntimeError(body.get("error", body["status"]))
        time.sleep(10)
    raise TimeoutError("O1 task did not finish inside the polling window")

print(wait_for_video(submit_o1("A glass of water tips over and spills across a wooden table")))

Two details in that loop are worth keeping even if you rewrite it. X-RateLimit-Reset on a 429 is a Unix timestamp for when the rate-limit window resets — not a number of seconds to wait — so subtract the current time before you sleep on it, or a literal reading of that header parks your worker for about fifty years. And the retry classes are narrower than they look: 500 and 503 are the failure statuses you retry as-is, while 429 takes the branch above, and a 400 or 402 will never fix itself.

Neither route needs a model-specific SDK: both are plain REST, so any HTTP client you already have works. The Modellix model pages ship ready-made snippets in cURL, JavaScript, Python, Go, Java, PHP, Ruby, Swift and PowerShell, which means you can start in the language your service is already written in rather than adopting a new client library for one model.

Kuaishou direct — the same task, one different envelope. The video route is POST https://api-singapore.klingai.com/omni-video/kling-o1 with a contents array instead of flat fields:

curl --location 'https://api-singapore.klingai.com/omni-video/kling-o1' \
--header 'Authorization: Bearer $KLING_API_KEY' \
--header 'Content-Type: application/json' \
--data-raw '{
  "contents": [
    { "type": "prompt", "text": "A girl sat on the train, looking out the window, her head swaying with the train." },
    { "type": "first_frame", "url": "https://example.com/start.png", "id": "image_1" }
  ],
  "settings": { "resolution": "1080p", "duration": 5, "audio": "off" },
  "options": { "callback_url": "", "external_task_id": "" }
}'

Poll that route with GET /tasks?task_ids=<id>; the task states are submitted, processing, succeeded and failed. Set options.callback_url if you would rather be pushed than poll — the protocol is in Kuaishou’s callback documentation. The image route is a different host path, POST /v1/images/omni-image, with model_name set to kling-image-o1.

Kling O1 parameters that break integrations (and what to send instead)

These are the constraints that produce a 400 rather than a video, and most of them are unique to O1 — inheriting a 3.0 request body will trip several of them at once.

1. A single input image locks duration to 5 or 10. On kling-video-o1-i2v, one image means only 5s or 10s are accepted; want 6 or 8, send two or more images. This is the most common O1 surprise, because 3–10 looks like a free choice.
2. There is no aspect_ratio on the I2V slice. Output aspect follows the first frame. If your pipeline needs 9:16, the input image has to be 9:16 — there is no field to override it.
3. audio is effectively off on most O1 paths. T2V and I2V accept off only. The reference-video slice accepts original, which preserves the source clip’s audio, but the O1 reference for this route notes that a feature video requires off. O1 does not generate audio — that is what 3.0’s native-audio tiers are for.
4. Ten seconds is a hard ceiling, and multi-shot is unavailable. O1 does not expose the multi_shot planning flag that 3.0 does. If the brief is a 30-second multi-scene advert, O1 is the wrong model and no parameter fixes that.
5. Reference images and elements share one budget: 7 combined when there is no reference video, 4 when there is one. Counting them separately and then adding a fifth element fails validation.
6. Last-frame-only is not supported. Send a first frame, or a first and a last frame — not a last frame alone. When you send both, you cannot add reference images on top.
7. kling-image-o1 defaults to a square. Omit aspect_ratio and the platform fills in 1:1, not your input’s aspect. Set it explicitly.
8. O1 image resolution stops at 2K. Modellix’s O1 page documents 1k and 2k. Kuaishou’s parameter reference lists a 4k enum on the shared omni-image endpoint, but that enum is governed per-model by its capability map, so treat 2K as the O1 ceiling until you have verified otherwise.
9. Element libraries are not carried over on the aggregated route. Modellix’s O1 image page states that element library IDs and series generation are not exposed, so if your workflow depends on reusable character elements, verify that path before you build around it rather than assuming the official element library carries over.
10. Input files have their own limits. Images: up to 50 MB, at least 300px per side, aspect ratio 1:2.5–2.5:1. Video: up to 200 MB, 3–10 seconds, 700–2160px per side, 24–60fps.
11. Watermarking is a request-time toggle, and custom watermarks are not supported. Kuaishou’s image route exposes watermark_info.enabled, and the video route’s options object covers the same setting. Set it explicitly rather than assuming a default.
12. The international host is region-specific. Kuaishou’s own examples use api-singapore.klingai.com, so the route most English-language documentation describes is the Singapore deployment. Keep the host in configuration alongside the model ID.

A quick sanity pass on any O1 request: is the input set one of the four shapes above, is the duration legal for that exact input count, and is audio either omitted or one of the values that slice actually accepts. And if the brief turns out to need motion transfer rather than physical reasoning — making a character perform a specific reference clip’s movement — that is a different endpoint with different rules; our Kling motion control API guide covers that route.

Calling Kling O1 through Modellix: one key, four routes

Everything above works on both routes; the reason to pick the aggregated one is operational rather than technical. One key covers the four O1 IDs plus the rest of the Kling line and the wider catalog — the Kling Video O1 model page lists the live rate for every parameter combination — billing is per call with no package to size or let expire, and the same async envelope and error format apply across every model, so the polling loop you just wrote does not need a second implementation when you add Veo, Seedance or Wan to the same product. Request history is filterable per end-user via an X-Mdlx-User-Id header attached at submit time, which makes per-tenant cost reporting possible without building your own ledger. If you would rather not poll at all, the platform accepts an X-Webhook-URL header on the submit call and POSTs the result once the task reaches a terminal state, with X-Modellix-Delivery-ID available for idempotent handling. The full workflow, including the File API for uploading your own reference frames, is in the Modellix REST API guide.

Four operational facts to plan around. Asset expiry is attached to each result rather than promised as a fixed window — the task-result schema carries a result_expires_at value, and the published examples place it roughly 24 hours after submission, so drive your own cache expiry from that field instead of a hard-coded number. Uploaded input files are a separate limit: about 7 days of retention, up to 16 MB each, 10 files per team. An empty balance returns 402, not a queue. And concurrency and requests-per-minute scale with the size of a single top-up, from 2 concurrent tasks and 100 RPM below $10 up to 100 and 1,000 RPM at $1,000, per the entitlements page.

Where the direct route still wins: for a single O1 model at predictable volume, buying Kuaishou’s prepaid units can land cheaper per second than a metered aggregator — the Modellix trade is one key and one bill across many vendors, not a guaranteed lower unit price. The unit price also falls to $0.126 once you commit to a larger package, and staying direct keeps you on Kuaishou’s newest capabilities the day they ship, including the element library this route does not expose. If O1 is the only model you will ever call, and you will call it steadily, price the packages before you default to a single key.

Kling O1 on the Modellix API

See the request schema, parameter enums, and live per-second pricing for all four Kling O1 endpoints behind one key.

View Docs

Errors, limits, and what to do about them

Both platforms return a flat JSON error envelope rather than an HTML error page, which is what you want in a pipeline. Modellix uses code and message, where code mirrors the HTTP status:

{ "code": 400, "message": "Invalid parameters: parameter 'prompt' is required" }

Status	Meaning on this route	Retry?
400	Missing or invalid field — most often a duration/input combination from the list above	No, fix the body
401	Invalid, missing or expired key	No
402	Balance exhausted	No, fund the account
404	Task ID or model not found	No
429	Rate or concurrency limit; read X-RateLimit-Reset	Yes, after the window
500 / 503	Platform-side failure	Yes, with exponential backoff (1s → 2s → 4s)

Kuaishou documents its own error taxonomy separately in its error code reference, and a failed task carries a message explaining why. Treat failed as terminal for that task rather than retrying the identical request: the statuses worth retrying are the transport-level ones in the table above, and a task that has already reached a terminal state is not one of them.

One integration decision worth making early: pick webhooks or polling, not both. Polling at a ten-second interval against a ten-second clip is fine; polling at one second across a hundred concurrent retries is how teams discover their RPM ceiling.

Start Building with Kling O1

Log in to Modellix to call the four Kling O1 endpoints and 200+ other image and video models through one API key.

Login

Frequently Asked Questions

What is the Kling O1 API?

It is Kuaishou’s reasoning-enhanced multimodal video API. You send a task description plus any mix of first frame, last frame, reference images and a source clip, and the model plans the sequence before rendering. Kuaishou exposes it as an omni video route and an omni image route; aggregators expose the same model as separate text-to-video, image-to-video, reference-video and image model IDs.

How much does the Kling O1 API cost?

On Modellix, as read on September 10, 2026: text-to-video and image-to-video at $0.0672/s in 720p and $0.0896/s in 1080p, the reference-video route at $0.1008/s and $0.1344/s, and image generation at $0.0224 per image. Kuaishou bills in prepaid units instead — $0.14 per video unit, $0.0035 per image unit — and lists Kling Image O1 at 8 units ($0.028) per image. Kuaishou’s public pricing page does not publish a per-second rate for the O1 video model, so there is no official number to compare the video rates against.

Is kling o1 api the same as kling video o1 api?

Yes. They resolve to the same model. Kuaishou’s naming puts “O1” on both the video and image sides of the reasoning track, and there is no separate video-only product, so both search phrasings describe the routes on this page.

What is the difference between Kling O1 and Kling 3.0?

O1 is the reasoning model: it plans before rendering, which is why it holds up on complex physical interaction and long, logically ordered prompts. Kling 3.0 and 3.0 Omni are the flagship generation line, and they are the ones that carry native audio, 4K output and multi-shot sequences. O1 caps at 10 seconds and 1080p with no multi-shot, so the two are complements rather than versions of each other — you route to O1 for the shots that have to be physically correct and to 3.0 for everything that needs length, sound or resolution. Our Kling 3.0 API guide covers the other side of that split, and the Kling 2.x generations sit below both.

Why does my Kling O1 image-to-video request fail when I ask for 8 seconds?

Because you sent exactly one input image. On the O1 image-to-video slice, a single image restricts the duration to 5 or 10 seconds. Send two or more reference images and the full 3–10 second range becomes available.

Does the Kling O1 API support audio?

Not as a generated track. On the text-to-video and image-to-video slices the audio field accepts off only. The reference-video slice accepts original, which preserves the source clip’s existing audio, but not a generated soundtrack. For spoken or generated audio you want the 3.0 line.

Can I use Kling O1 for a reference-based edit of an existing clip?

Yes — that is the kling/kling-video-o1 route, which takes exactly one reference video plus up to four images, and supports restyling and editing in natural language. Keep audio at off if the source clip is being used as a feature reference, and remember the ten-second ceiling applies to the output.

Which Kling O1 endpoints does Modellix expose?

Four, as of September 10, 2026: kling/kling-video-o1-t2v, kling/kling-video-o1-i2v, kling/kling-video-o1 for reference-video work, and kling/kling-image-o1. They share one key, one asynchronous submit-and-poll pattern and per-call billing.

Is there a free Kling O1 API tier?

Not self-serve, on either route. Kuaishou sells prepaid unit packages, and the smallest ones are still paid commitments with an expiry clock. On Modellix, the signup credit was retired on August 19, 2026 — new accounts no longer receive a complimentary credit, and trial credit is requested by emailing support@modellix.ai, as recorded in the Modellix changelog. The cheapest way to evaluate O1 is one short 720p clip: at $0.0672 per second, a five-second test costs about thirty-four cents.

---

Model IDs, endpoint behaviour and pricing reflect public information as of September 10, 2026 and change without notice — Kuaishou retires legacy models on its own schedule (a September 15, 2026 retirement list is already published, though Kling O1 is not on it), and aggregator catalogs shift with each release. Validate the specific model page and price before you commit budget. This article was written by Modellix, an API aggregator with a commercial interest in the single-key route it describes; the Kuaishou documentation summarised above is vendor-neutral, and the rates quoted are a same-day snapshot rather than a standing claim. Access Kling and 200+ other image and video models through one API key at modellix.ai.

Cover image: illustrative Modellix artwork; it is not a Kuaishou product screenshot or source evidence.