Kling Camera Control

Kling Camera Control is a pure-configuration node: it packages a manual camera move into a KLING_CAMERA object you can hand to any Kling video node that accepts one. No API call, no credits, no auth input - it's just a structured description of how the virtual camera should move during generation. It exists because the whole point of using Kling's API instead of, say, a fixed local sampler is that you can direct the camera, and this is the node that lets you do it by hand instead of picking from a preset list.

For that reason it pairs with the pack's camera-aware generation nodes - Image-to-Video, Keyframe Video, and Text-to-Video all expose an optional camera_control input. Without a camera node wired in, Kling decides the move on its own (or sits static); with one, you're the cinematographer.

How it works

The node has seven inputs: a type dropdown plus six numeric axes. The type matters because it tells Kling which family of movement you're describing - simple, horizontal, vertical, pan, tilt, roll, or zoom - and then the six floats fine-tune it. Each axis runs from -10 to 10, all defaulting to 0:

• horizontal / vertical - the camera physically translating (trucking / pedestal).
• pan / tilt - the camera rotating in place (swing left-right, nod up-down).
• roll - rotating the horizon (Dutch angle).
• zoom - dolly-style zoom; negative is zoom out.

That's the list - the tooltips in the node are the author's own description and they're accurate: "Camera pan (-10 to 10)", etc. The single output is KLING_CAMERA, which is really just a small dict holding the type plus a config of whatever axes you set. Wire it into a video node's camera_control input and you're done.

Where it shines (and where it doesn't)

Use it when you want a specific, repeatable move - a slow push-in on a portrait, a subtle pan across a landscape - that a preset doesn't quite capture. It's also the node to reach for when you're experimenting, because a manual control is easy to reason about: change one number, re-run, compare.

Don't bother with it when a preset would do. The pack's Kling Camera Preset node (orbit, dolly, crane, etc.) gives you 15 cinematic moves with an intensity slider and is less fiddly for common shots. And keep the values modest: the scale is -10..10 and Kling interprets it as a strength, so maxing every axis at once tends to produce vertigo, not cinema. Start near 1–3 and tune up.

Practical wiring

• Image-to-Video / Keyframe Video / Text-to-Video → connect camera_control output to the node's optional camera_control input.
• Combining with presets: you can't wire both Camera Control and Camera Preset into the same generation node - they're alternative producers of the same KLING_CAMERA type. Pick one per video. If you want a preset with more of one axis, just set the preset's intensity instead.

Common issues

• Move ignored - the camera move is most effective when the scene actually warrants motion (and pro mode responds better than std). A perfectly static prompt with a big dolly can read as "nothing happened."
• Everything set to 0 with type: simple - you've produced an empty camera object. That's a legal no-op, not a bug; either give it a type and some values or skip the node entirely.
• camera_control input missing on your generation node - make sure you're using a node in this pack that exposes it (I2V, Keyframe, T2V); the optionals differ node to node.

Install

Part of ComfyUI-Kling-Direct, so nothing extra to fetch:

cd ComfyUI/custom_nodes
git clone https://github.com/IxMxAMAR/ComfyUI-Kling-Direct

or ComfyUI Manager → search "Kling Direct" → install → restart. No models, no dependencies beyond ComfyUI's bundled libraries. The whole node is a few lines of Python that pack a config dict - which is exactly why it's dependable.