Newsletter image

Subscribe to the Newsletter

Join 10k+ people to get notified about new posts, news and tips.

Do not worry we don't spam!

By pressing the Subscribe button, you confirm that you have read and are agreeing to our Privacy Policy and Terms of Use

Search

GDPR Compliance

We use cookies to ensure you get the best experience on our website. By continuing to use our site, you accept our use of cookies, Privacy Policy, and Terms of Service.

Kling - Image Generation, Ecosystem

Kling Image 4.0

Kuaishou's Kling Image 4.0 ships native 8K and 2,000 characters of in-image text, with no weights and no readable API docs. The full schema is in a ComfyUI node merged the night of the launch, reference images are now billed, and the seed is decorative.

License Proprietary
License Proprietary
TL;DR
  • Native 8K, up to 2,000 characters of legible text in one image, and coherent sets of 2 to 10 images from a single prompt.
  • The complete request schema is not in Kling's docs: it is in a ComfyUI node that opened and merged two hours and fifty minutes apart, the same evening the model launched.
  • The seed parameter is decorative. Results are non-deterministic regardless of seed, so nothing you generate here is reproducible.
System Requirements
RAMNo local path: Kuaishou has published no weights for any Kling Image generation
GPUNone. The model runs only on Kling's hosted API
VRAMA Kling API key, or an aggregator that already carries the four Kling Image 4.0 model ids

Kuaishou shipped Kling Image 4.0 on the evening of 17 November with one headline number: native 8K. The number is real, and it is not the part that will change what you spend. Three rows further down the price list, reference images stopped being free. And the complete request schema is not in Kling's documentation at all, because Kling's developer pages render client-side and hand a plain HTTP fetch an empty shell: it is in a ComfyUI pull request that opened and merged the same evening the model launched.

What shipped on 17 November

Kling is Kuaishou's generative media line, and Kling Image is the still-image half of it. Version 4.0 is the fourth generation, it has no published weights, and it is reachable only through Kling's hosted API or their own studio. Kuaishou opened the API to developers and enterprises on launch day rather than staging it behind a waitlist.

FactValue
AnnouncedEvening of 2026-11-17, China time
WeightsNone published, hosted API only
Resolutions2K, 4K, native 8K
Aspect ratios8, plus auto
Images per prompt1, or a coherent set of 2 to 10
Text rendered in-imageUp to 2,000 characters
Typography7 languages, 70+ preset commercial fonts
Reference imagesUp to 10, billed per reference
Prompt ceiling50,000 characters, 166,000 for long image
ArchitectureKuaishou calls it unified understanding and generation

Kuaishou pitches the model at advertising, storyboards, e-commerce listings and film production. There is still no independent evaluation of Kling Image 4.0 and nothing on any image-generation leaderboard, so every quality claim attached to it is the vendor's own. Two of those claims are checkable without a benchmark, so we checked them.

We ran both headline claims through the model

Two claims carry this release: native 8K, and legible text inside the image. The two figures below are the raw returns, not a picked best of several attempts. Each was a single call at 8K in 3:4 through kwaivgi/kling-image-v4.0/text-to-image, billed at 4 credits apiece, and each came back as a 7040 by 9344 pixel PNG of roughly 100 MB. That is 65.8 megapixels, so the resolution claim is true at the file level before you even ask whether the detail inside it is real.

A matte dark grey spec card standing upright on concrete, printed with the heading NATIVE 8K above four rows of smaller specification text, every line sharply legible
Text to image, 8K, 3:4, one image, 4 credits. Every line came back correct. Click it for the full image and the prompt. Created with photoproduct.io

The typography test asked for six separate pieces of English text on a printed card, including a line of fine print along the bottom edge. All six came back correct, character for character: the heading, the four specification rows, and "rendered by Kling Image 4.0" in mixed case at the smallest size on the card. No garbled glyphs, no invented letters, no dropped words, and consistent letterforms down every line.

On the evidence of one run, in-image text is the real advance here, and it is precisely the thing open-weight image models still fall apart on. The model did quietly ignore one instruction: we asked for the card held flat to camera and got it turned a few degrees with a soft contact shadow instead. It is a better photograph than the one we asked for, which is worth knowing if you are art-directing tightly rather than fishing for a good result.

Extreme macro photograph of a human eye, with the small figure of a person throwing both arms up and shouting visible inside the pupil
Text to image, 8K, 3:4, one image, 4 credits. The detail is real, the optics are not. Click it for the full image and the prompt. Created with photoproduct.io

The detail test is the harder one, because resolution is trivial to claim and trivial to fake by upscaling a smaller render. Viewed at full size the iris resolves genuine crypt and collarette structure, individual lashes separate and cast their own shadows onto the lid, and the reflected figure's fingers, open mouth and hair all hold together at 1:1. There is real film grain rather than the smeared interpolation an upscale leaves behind. Whatever happens upstream, this is not a 2K render stretched to fill a bigger canvas.

It is also optically wrong, and that is the more useful half of the result. We asked for a reflection sitting on the wet convex surface of the cornea, with the compression and limbal falloff a real reflection has. What came back is a picture composited inside the pupil, with iris fibres visibly overlaying the figure's body along the bottom of the disc. The model read "a person reflected in an eye" as a visual trope rather than as a physical event, and rendered the trope beautifully. Keep that in mind before trusting it with anything where the physics has to survive scrutiny: a product reflection, a mirror, a shot through glass.

One model name, four shapes

"Kling Image 4.0" is not one thing you call one way. It is two API routes that behave as four distinct products, and the one you pick changes the price by a factor of fourteen.

ShapeInputOutputResolutionsGood for
Single imagePrompt, 0 to 10 referencesOne image2K, 4K, 8KHero shots, print, anything you crop or enlarge
EditPrompt plus 1 to 10 referencesOne image2K, 4K, 8KScene swaps, held subjects, compositing
Image setPrompt, 0 to 10 references2 to 10 consistent images2K, 4K, 8KStoryboards, angle sets, character sheets
Long image, e-commerce1 to 3 product photosOne tall product detail page1K, 2KMarketplace and listing pages
Long image, webpageOptional style and subject refsOne tall page design1K, 2KLanding page comps and layout drafts

The first three are the same endpoint with a different result_type and a different number of references attached. The long-image pair is a separate endpoint entirely, with its own settings object, its own resolution ladder and its own price table. The e-commerce variant is image-to-image only: it will not produce a product page from text alone.

Text to image is one frame from a prompt, with up to ten optional references to steer it. This is the only variant where paying for 8K clearly makes sense, because it is the only output you are likely to crop hard, enlarge or send to print. Reach for it for a hero image, a single ad frame, or any one-off where resolution is the point of the exercise.

Edit is the same endpoint with the references carrying the work: up to ten images combined into one new photorealistic result. It is the variant for dropping an existing product into a new scene, holding a subject fixed while everything around it changes, or compositing objects that were never photographed together. The prompt has to address references by name, as @Image1 through @Image10, so a vague prompt wastes the references and the charge for them.

Image set returns 2 to 10 images holding the same characters, products and style across the batch. This is the one capability here that you cannot fake by calling a single-image model repeatedly, which makes it the most interesting variant for storyboards, product angle sets and character sheets. Every image bills at the full per-image rate, so a ten-image 8K set costs ten 8K stills and not a batch discount.

Long image returns one tall image that is a whole page rather than a picture. The e-commerce skill turns one to three product photographs into a finished detail page at a short, medium or long setting, and the webpage skill designs a layout around an optional style and subject reference. Both cap at 2K, which is the real constraint on the output, and both need the language named in the prompt or an English brief can come back with Chinese typography.

The complete schema lives in an open-source integration

Kling publishes no server-rendered release notes and no public API reference you can read without a browser session. We checked kling.ai/release-notes, kling.ai/dev/pricing and the global developer document page on 19 November: all three return HTTP 200 and no readable content to curl.

The schema is instead fully specified in ComfyUI, which is open source. Pull request 17797 opened at 19:05 UTC on 17 November and merged at 21:55 UTC, two hours and fifty minutes later, the same evening Kuaishou announced the model. It added Kling4ImageNode and Kling4LongImageNode to comfy_api_nodes/nodes_kling.py, with every enum, bound and validation rule spelled out in Python. A follow-up merged the next afternoon, adding 4:3 and 3:4 to the Kling 4.0 video nodes; the image node already had them.

That is the open-source angle on a closed model, and it is worth saying plainly. For a developer outside China, the authoritative description of Kling Image 4.0 right now is a file in a repository Kuaishou does not own. Two routes carry everything:

{
  "contents": [
    { "type": "prompt", "text": "Studio shot of @image_1 on a linen backdrop" },
    { "type": "refer_image", "url": "https://example.com/mug.png", "id": "image_1" }
  ],
  "settings": {
    "result_type": "series",
    "series_amount": 4,
    "resolution": "8k",
    "aspect_ratio": "16:9"
  }
}

The request is a list of typed content blocks plus a settings object, which is closer to a chat-completions message array than to the flat form bodies most image APIs still use. Reference images arrive as refer_image blocks with an id, and the prompt addresses them by that id. The long-image route uses style_refer_image and subject_refer_image block types instead, and swaps settings for skill, resolution and length.

What an image costs, in Kling's own units

Kling prices the API in an internal unit rather than currency, and the ladder is steep. These are the published per-image unit counts.

Mode1K2K4K8K
Single image or set, per imagen/a162440
Long image, webpage140152n/an/a
Long image, e-commerce short6072n/an/a
Long image, e-commerce medium120140n/an/a
Long image, e-commerce long200220n/an/a
Each reference image or element0.8

Two things jump out. An 8K still is 2.5 times a 2K still, so resolution is the single biggest lever in the whole model. And a long e-commerce page at 2K costs 220 units, which is more than five 8K stills, for one tall image.

Reference images became a billable line

The 0.8-unit charge per reference is new, and Kling's documentation says so explicitly: this differs from previous models, where reference images and reference elements were free. On its own, 0.8 units is noise next to a 40-unit 8K render.

It stops being noise in a set. Ten references on a ten-image 8K set is 400 units of images plus 8 units of references, but the references are charged once, not once per output. The failure mode is the other shape: a batch job that re-sends the same ten product photos for every one of a hundred single-image calls pays the reference charge a hundred times. If you are building a pipeline, upload once and reuse the hosted URL rather than attaching references per call.

We checked the whole price list against the code

Unit counts from a vendor pricing page are worth verifying, so we did. ComfyUI's nodes carry a price-badge expression that computes what a run costs before you press go, and those figures are in dollars rather than Kling units. Dividing one by the other should give the same constant everywhere if both are describing the same price list.

PointKling unitsComfyUI expressionPer 1,000 units
2K single160.090095.631
4K single240.134425.601
8K single400.224515.613
Webpage 1K1400.785075.608
Webpage 2K1520.852285.607
E-commerce 1K short600.336055.601
E-commerce 1K medium1200.672105.601
E-commerce 1K long2001.121125.606
E-commerce 2K short720.403265.601
E-commerce 2K medium1400.785075.608
E-commerce 2K long2201.232665.603
Reference image0.80.004295.363

Eleven of the twelve points we checked land between 5.601 and 5.631 per thousand units, a spread of 0.53%. That is a single constant multiplier applied to a published unit list, which means the unit counts above are almost certainly correct: twelve independently wrong numbers do not produce one constant ratio.

The reference-image charge is the lone outlier at 5.363, about 4.4% below the cluster. Either the 0.8-unit figure is slightly off, or references are deliberately priced a little under the straight conversion. It cuts in the reader's favour either way, and it is the only row in the table we would not bet on to the second decimal.

The seed does nothing

There is a seed parameter, it takes any integer from 0 to 2147483647, and it does not do what you think. The ComfyUI node documents it in one line: seed controls whether the node should re-run, and results are non-deterministic regardless of seed.

Read that again if you were planning to version-control a prompt and a seed and expect the same image back. Kling Image 4.0 has no reproducibility guarantee at all. For an A/B test, a regression suite or a design system that needs the same asset regenerated next quarter, this is disqualifying, and it is the single most important thing in this article for anyone building on top of the model. Save the output, not the recipe.

The input rules that will cost you a run

Reference images have hard bounds that are not advertised anywhere a user would look, and breaking them fails the request after you have already uploaded. There are at most 10 of them. Each must be at least 300 by 300 pixels, and each must have an aspect ratio between 2:5 and 5:2, so a tall banner or a wide panorama is rejected outright.

The prompt addresses references as @Image1 through @Image10, which the client rewrites to @image_1 before sending. Naming an index you did not attach is a hard error rather than a silent ignore, which is the right call and worth knowing before you template your prompts. Checking the bounds locally costs nothing:

for f in refs/*.png refs/*.jpg; do
  magick identify -format '%f %wx%h ' "$f"
  magick identify -format '%[fx:(w>=300 && h>=300 && w/h>=0.4 && w/h<=2.5) ? "OK" : "REJECT"]\n' "$f"
done

Prompts themselves are generous. The image route accepts 1 to 50,000 characters, and the long-image route accepts up to 166,000, which is roughly a 25,000-word brief for a single page design. That ceiling tells you what Kuaishou expects you to send: not a sentence, but a full layout specification.

Image sets: 2 to 10, or auto

The series_amount parameter takes disabled, auto, or a number from 2 to 10. Set a number and you get exactly that many images holding the same characters and style. Set auto and the model decides how many the prompt needs, anywhere in that range.

auto is a pricing hazard rather than a convenience. Every image in the set is billed at the full per-image rate, so an auto set at 8K is a request whose cost varies between 80 and 400 units depending on how the model reads your prompt. ComfyUI's own price badge shows it as a range rather than a number for exactly this reason. Pick an explicit count in anything automated.

Long image is two different products

The long-image route takes a skill of either ecommerce or webpage, and they are not variations on a theme. The e-commerce skill takes one to three product photographs and a length of short, medium or long, and returns a complete product detail page as a single tall image. The webpage skill takes an optional style reference and an optional subject reference and designs a page layout around them.

The webpage skill carries a gotcha its own tooltip flags: name the output language explicitly in the prompt, as in "All visible text must be in English only." A model trained heavily on Chinese e-commerce pages will otherwise give you Chinese typography on an English brief. Given that in-image text rendering is the flagship feature here, getting it in the wrong script is a 152-unit mistake.

Calling it from an agent

If you are reaching the model from a coding agent rather than a browser, the four shapes show up as four flat model ids, which is a better fit than one endpoint with a mode switch. On photoproduct the credit cost of the default request is quoted before anything runs:

Model idDefault requestCredits
kwaivgi/kling-image-v4.0/text-to-image2K, 1:1, one image2
kwaivgi/kling-image-v4.0/edit2K, one image, references in2
kwaivgi/kling-image-v4.0/image-set2K, four images6
kwaivgi/kling-image-v4.0/long-image1K, e-commerce, medium10

Those are the defaults, and the quote moves with the parameters you actually pass: 8K and a ten-image set both cost more than the row above. The request shape puts the prompt inside params:

{
  "model": "kwaivgi/kling-image-v4.0/text-to-image",
  "params": {
    "prompt": "Packaging mockup, matte black box, studio lighting",
    "resolution": "8k",
    "aspect_ratio": "16:9",
    "num_images": 1,
    "output_format": "png"
  }
}

Splitting one endpoint into four ids is the right call for agent use, and it is the same argument we made in what an agent needs from a generation API: an agent that has to set result_type correctly to avoid a surprise ten-image bill is an agent that will eventually get it wrong. A model id that encodes the mode cannot be misread.

Kuaishou's open image weights are 28 months old

Kuaishou does publish open image weights, which makes the contrast sharper than it is for most closed vendors. The Kolors team ships under Apache 2.0, and Kolors itself is a capable SDXL-architecture text-to-image model with 882 likes on Hugging Face.

It was last touched on 2024-07-12. That is 28 months ago. Everything the team has published since is research rather than a successor base model: CoTyle, a style-code model built on top of Qwen-Image and last updated in November 2025, and MetaView, a novel-view-synthesis paper from ECCV 2026 with zero downloads. There is no Kolors 2.

So the same company runs both lanes and has quietly stopped resurfacing the open one. If you want an open-weight image model you can actually run, the frontier is Qwen-Image-2.1 and the FLUX line, not anything from Kuaishou. Nothing with open weights does native 8K today, and nothing open does page layout at all, so the gap Kling Image 4.0 is pointing at is real. It is just not a gap Kuaishou is helping to close.

Limitations and gotchas

The weights are closed and there is no sign of a release. The seed is decorative, so nothing you generate is reproducible. The 8K claim has no independent evaluation behind it, and the model is absent from every public image leaderboard, so quality against Qwen-Image, FLUX or Nano Banana Pro is currently unknown.

Long image caps at 2K, which is a constraint you feel immediately: a tall product page at 2K is low resolution along its long edge. The e-commerce skill refuses to work from text alone. Reference images are now billed, and the 2:5 to 5:2 aspect bound quietly rejects exactly the tall and wide crops a page designer reaches for first. And Kling's own developer documentation is unreadable without a browser session, which for an API product in 2026 is a choice rather than an oversight.

Who should use it

E-commerce and advertising teams shipping listings. This is the use case the model was built for, and the long-image e-commerce skill has no open-weight equivalent whatsoever. If you are producing product detail pages at volume, it is worth the evaluation time even at 220 units a page.

Anyone who needs legible typography inside an image. Two thousand characters, seven languages and 70 commercial fonts is a far stronger text story than open-weight image models currently offer, and in-image text is where most of them still fall apart. Specify the language in the prompt and check the output.

Not anyone who needs reproducibility or local inference. If your pipeline has to regenerate the same asset twice, or has to run without a network, this model cannot do either, and no amount of prompt discipline changes that. Our self-hosted stack guide and the open-weight gap analysis cover what you give up and what you get back by staying local. For the hosted side of the market more broadly, our generator API comparison has the surrounding context.

Sources and further reading

The ten-minute version: pull comfy_api_nodes/nodes_kling.py, read the hundred lines from Kling4ImageNode down, and you will know more about this model's actual interface than any vendor page will tell you. Then run your reference images through the aspect-ratio check above before you spend anything, because that is the failure that costs a credit and teaches you nothing.

No benchmark, leaderboard run or model-to-model comparison was performed. Every figure comes from Kuaishou's launch materials, the merged ComfyUI integration source, Hugging Face metadata, or our own arithmetic on those numbers. The two images are our own output from Kling Image 4.0, one call each at 8K, 4 credits apiece, shown exactly as returned and not retouched or re-rolled.
Date checked: 2026-11-19

The typography test

kwaivgi/kling-image-v4.0/text-to-image, resolution 8k, aspect ratio 3:4, one image. Returned 7040 x 9344 px, 99.5 MB PNG. Billed 4 credits. Created with photoproduct.io

Full view of the generated spec card, showing the heading NATIVE 8K, four specification rows and a line of fine print reading rendered by Kling Image 4.0

The prompt, in full:

A cinematic studio product still photograph captured on a real set, a straight-on hero composition of a single matte dark charcoal card standing upright on a pale polished concrete surface, the card filling the centred vertical column of the frame, the background falling away into soft neutral grey depth.

The card is a thick matte board with a faint fibrous paper texture and a clean bevelled edge catching a thin highlight along its left side. Printed on its face in crisp white sans-serif type, perfectly sharp and fully legible: the heading NATIVE 8K in large letters across the top, and below it four short labelled rows reading RESOLUTION 7680 x 4320, ASPECT RATIOS 8 PLUS AUTO, SET SIZE 2 TO 10 IMAGES, and SEED NON DETERMINISTIC, each row evenly spaced with generous margins. A single line of smaller fine print runs along the bottom edge reading rendered by Kling Image 4.0. All visible text must be in English only, sharply rendered, correctly spelled, and fully readable.

The card face is held perfectly flat to the camera and tack sharp from corner to corner, lit by a large soft frontal source that reads the type evenly with no glare, no hotspot and no falloff across the printed area. A gentle directional key from camera-left models the card's edge and lays a soft contact shadow onto the concrete to the right, grounding the object in real space.

The concrete surface carries real aggregate speckle and fine surface wear, falling out of focus toward the back of the frame where light atmospheric depth separates the card from the neutral background.

Captured with a wide-latitude cinema look on a clean normal prime at a moderate aperture, natural round bokeh behind the subject while the entire card face stays in critical focus. Gentle filmic highlight roll-off never clipping to pure white, lifted blacks that stay open and never crush, full detail held in both shadows and highlights. Real paper fibre, real board weight, real printed ink sitting on a real surface. Colour-negative motion-picture film rendition with fine theatrical 35mm film grain across the frame, the grain never softening or breaking up the printed type. No HDR overprocessing, no digital oversharpening, no plastic rendering, no garbled or invented lettering, photographed not generated, captured on a real camera by a real cinematographer.

The detail test

kwaivgi/kling-image-v4.0/text-to-image, resolution 8k, aspect ratio 3:4, one image. Returned 7040 x 9344 px, 97.2 MB PNG. Billed 4 credits. Created with photoproduct.io

Full view of the generated eye macro, the iris showing fine fibre structure and a small shouting figure with raised arms rendered inside the pupil

The prompt, in full:

A cinematic macro still photograph captured on a real cinema set, an extreme close-up detail composition of a single human eye filling the entire frame, the camera straight on at the eye's own level, the iris anchored just above the centre line, the lower lash line reading across the bottom third, the composition holding a quiet held-breath stillness.

The eye reads as real human biology at macro range. The iris is a dense fibrous structure of warm amber radiating out of the pupil into a deep teal outer ring, individual crypts and collarettes resolving across the stroma, the pupil a true black well with a soft specular catchlight at its upper edge. Individual lashes separate cleanly, each casting its own fine shadow onto the lid. Fine soft even pore texture and real peach fuzz across the lid and the skin at the outer corner, subsurface scattering warming the thin skin at the tear duct and the lash root into semi-translucent biology, never opaque plastic, never waxy, never harsh clinical detail.

Mirrored in the wet convex curve of the cornea, small but clearly resolved and legible, is the reflection of a person standing in a bright open space with both arms thrown up above their head, mouth wide open mid-shout, body arched back in unmistakable delight. The reflection is compressed and curved by the corneal surface exactly as a real reflection would be, brightest at the centre and falling away toward the limbal edge, the bright room behind them reading as a soft blown field of warm light.

The tear film sits as a genuine wet layer across the whole cornea with real surface tension and a fine meniscus along the lower lid. Depth of field is shallow enough that only the iris plane and the reflection within it hold true sharpness, the outer corners of the frame falling softly away.

Real human skin captured on a real cinema camera, refined and real, real natural pore texture soft fine and even, subsurface scattering with warm undertone bleed reading as semi-translucent biology never opaque plastic. No retouching, no skin smoothing, no porcelain plastic look, no waxy render, no blemishes, no enlarged or rough pores, no harsh clinical texture. Lashes rendered strand by strand with realistic separation. Captured with a wide-latitude cinema look on a long macro prime at a wide aperture, natural round bokeh, gentle filmic highlight roll-off never clipping to pure white, lifted blacks that stay open and never crush. Colour-negative motion-picture film rendition, fine theatrical 35mm film grain across the entire frame including skin, iris and atmosphere. No HDR overprocessing, no digital oversharpening, no plastic rendering, photographed not generated, captured on a real camera by a real cinematographer.
Prev Article
Kimi K3.1 Pro
Next Article
OpenThinker-32B

Related to this topic: