Save 4 hours! We auto-setup your workflow! Free!

Drop your workflow.json — we handle every dependency, custom node, and model. Just open the link and run.

Auto-Setup Workflow Json (Free) Now!
ComfyUI > Nodes > OpenKatana > OpenKatana · Process clip

ComfyUI Node: OpenKatana · Process clip

Class Name

OpenKatana_process_clip

Category
OpenKatana/Tools
Author
rk0neki (Account age: 235days)
Extension
OpenKatana
Latest Updated
2026-11-05
Github Stars
0.05K

How to Install OpenKatana

Install this extension via the ComfyUI Manager by searching for OpenKatana
  • 1. Click the Manager button in the main menu
  • 2. Select Custom Nodes Manager button
  • 3. Enter OpenKatana in the search bar
After installation, click the Restart button to restart ComfyUI. Then, manually refresh your browser to clear the cache and access the updated list of nodes.

Visit ComfyUI Online for ready-to-use ComfyUI environment

  • Free trial available
  • 16GB VRAM to 80GB VRAM GPU machines
  • 400+ preloaded models/nodes
  • Freedom to upload custom models/nodes
  • 200+ ready-to-run workflows
  • 100% private workspace with up to 200GB storage
  • Dedicated Support

Run ComfyUI Online

OpenKatana · Process clip Description

Requests OpenKatana clip processing from ComfyUI, including subject-tracking mask generation.

OpenKatana · Process clip:

OpenKatana_process_clip provides a tool-based way to request processing of an individual clip in an OpenKatana project from your ComfyUI workflow. It connects your workflow to OpenKatana’s clip-processing functionality, which includes processing through configured ComfyUI services. The supplied context shows a point-guided subject cutout workflow: you identify the subject on the clip’s first frame, and a SAM2 video segmentation model follows that subject through the clip to generate a mask for each source frame. This can help you isolate a subject for later compositing without manually drawing a separate mask on every frame. The node acts as a request wrapper rather than directly exposing image-processing controls, so the available operations and their configuration depend on the underlying OpenKatana tool. The provided excerpts do not establish the complete list of supported processing modes.

OpenKatana · Process clip Input Parameters:

project_id

A required STRING identifying the OpenKatana project associated with the processing request. The node passes this value, together with your argument text, to the argument-preparation helper before invoking the tool. Use the identifier of the project containing the clip you intend to process; a project identifier is not the same as a clip identifier or a video filename. Selecting the correct project establishes the context in which the processing request is prepared. The supplied interface does not specify a default value, allowed identifier format, minimum or maximum length, or a list of valid identifiers.

arguments

A required STRING containing the arguments used to prepare the underlying processing request. This is where you provide the tool-specific configuration that is not exposed as separate sockets on this node. The node sends this text through its argument-preparation helpers before calling the tool; however, the supplied code does not show those helpers or the exact argument schema for OpenKatana_process_clip. Follow the tool’s documented argument format rather than assuming that the internal processing function’s parameter names are all accepted directly. The context establishes that clip processing involves a target clip and processing configuration, and that the cutout workflow requires an installed SAM2 model and subject-selection points, but it does not establish a complete request example for this node. No default value, length limits, or selectable options are specified in the supplied interface.

after

An optional STRING accepted by the node, with a Python execution default of None when omitted. In the supplied implementation, this value is accepted by the execution method but is not referenced when preparing arguments or invoking the tool. Consequently, the visible code does not establish any effect on clip selection, processing settings, or the returned result. Do not treat it as a processing option or assume that its text is forwarded to OpenKatana. If another part of your workflow uses this socket for graph connections, that behavior is outside the supplied implementation. No string default, allowed options, or minimum and maximum lengths are specified.

OpenKatana · Process clip Output Parameters:

result_json

A STRING containing the tool response after it has been passed through the shared response-formatting helper. This is the node’s only output, so it is the place to inspect the processing response rather than expecting an IMAGE, MASK, or VIDEO socket directly from this node. The output name indicates a JSON response, but the supplied code does not show its exact structure or guarantee particular fields. Interpret any status information, generated-file references, or error details according to the actual returned content rather than assuming fixed field names. In the cutout workflow shown in the context, the underlying processing graph saves mask images; the excerpt does not establish how those saved files are represented in this response.

OpenKatana · Process clip Usage Tips:

  • Start with a project and clip that already exist in OpenKatana. Keep their identifiers distinct: project_id has its own socket, while the target clip must be specified according to the processing tool’s argument schema.
  • Confirm the accepted arguments format before building a larger workflow. The internal processing function signature provides implementation context, but it is not sufficient evidence for a complete JSON request or the tool’s supported options.
  • For the cutout workflow, choose an installed SAM2 model. The supplied implementation explicitly requires a model choice and gives sam2.1_hiera_base_plus.safetensors as an example; that filename is not a guarantee that the model is installed in your environment.
  • For point-guided cutouts, select the subject on the clip’s first frame. The shown workflow applies the point prompts at frame index 0 and propagates the segmentation through the video, so choose points that clearly distinguish your subject at that starting frame.
  • Use negative points, when supported by your request configuration, to identify areas that should be excluded from the cutout. The shown graph attaches negative-point coordinates only when they are provided.
  • Plan for whole-clip processing costs. The cutout graph loads the video with no frame cap and selects every frame, then generates a mask for each source frame. Testing on a shorter clip first can help you assess mask quality and resource requirements.
  • Check the processing environment before changing device or precision settings. The cutout workflow builder uses cuda and fp16 by default, but the supplied node interface does not confirm whether those settings can be overridden through this tool’s arguments.
  • Inspect result_json after each initial test. Use the returned response to determine the next step rather than connecting this STRING output directly to nodes that require image or mask data.

OpenKatana · Process clip Common Errors and Solutions:

Specify an installed SAM2 model choice, e.g. sam2.1_hiera_base_plus.safetensors

  • Explanation: This exact error is raised by the supplied cutout workflow builder when its model setting is missing or empty. The segmentation workflow cannot be constructed without a model choice.
  • Solution: Select an installed SAM2 model and supply it using the processing tool’s documented argument structure. Verify that the chosen filename matches an available model rather than copying the example without checking your installation.

unexpected inputs: ...

  • Explanation: This exact message pattern is raised by the node wrapper when execution receives named fields that are not declared in its typed input definitions. The authoritative interface exposes only project_id, arguments, and optional after.
  • Solution: Remove unsupported named inputs from custom calls or modified workflows. Put processing configuration inside arguments using the tool’s supported schema instead of adding new sockets such as model or clip_id.

Invalid or unsupported arguments format

  • Explanation: This is a troubleshooting category, not a literal error message shown in the supplied code. The argument-preparation helpers may reject text that does not match their expected syntax or the processing tool’s required fields; their validation rules are not included in the excerpts.
  • Solution: Check the OpenKatana_process_clip tool signature and argument documentation. If the tool expects JSON, use valid JSON with double-quoted keys and strings, and remove trailing commas. Do not assume that correcting JSON syntax alone resolves missing or unsupported fields.

Project or clip cannot be found

  • Explanation: This is a possible downstream failure rather than a confirmed error string from the supplied implementation. A request cannot process the intended clip if it references the wrong project or a clip that is unavailable in that project.
  • Solution: Verify the project identifier, confirm that the clip is present in that project, and check the clip reference in your processing arguments. Use the actual identifiers supplied by OpenKatana rather than display names or source filenames unless the tool explicitly accepts those values.

SAM2 model cannot be loaded

  • Explanation: This is a possible processing-stage failure, not an exact message supplied in the context. Providing a nonempty model choice passes the visible missing-model check, but does not establish that the model exists or can be loaded by the configured processing service.
  • Solution: Verify that the selected model is installed in the environment running the workflow and that its filename is correct. Check that the required SAM2 nodes are available, and consult the processing service’s error details for the specific loading failure.

Required processing nodes are unavailable

  • Explanation: This is a possible downstream failure rather than a quoted error message. The shown cutout graph depends on nodes including VHS_LoadVideo, DownloadAndLoadSAM2Model, OpenKatanaPoints, and SAM2 video segmentation nodes. If the processing service cannot resolve them, the graph cannot run.
  • Solution: Check that the ComfyUI instance executing the processing graph has the required node packages installed and loaded. Use that instance’s logs to identify the missing node type before installing or updating dependencies.

GPU memory or device error during cutout processing

  • Explanation: This is a possible runtime failure, not a confirmed error string. The shown workflow defaults to CUDA with FP16 precision and processes the full clip, which may exceed available resources or fail in an incompatible environment.
  • Solution: Test with a shorter clip and, where your preparation workflow allows it, a lower-resolution source. Confirm that the processing environment supports the configured device and precision. Only change those settings through options that the tool actually supports.

The next node rejects result_json as an image or mask

  • Explanation: OpenKatana_process_clip returns a STRING response, not an image or mask tensor. Even when the underlying workflow generates mask images, this output socket remains a textual tool response.
  • Solution: Inspect the returned content for the actual result details. If it provides saved-file references, use an appropriate loading step to bring those files into your image or mask workflow rather than connecting the response string directly to an image-processing input.

OpenKatana · Process clip Related Nodes

Go back to the extension to check out more related nodes.
OpenKatana
RunComfy
Copyright 2025 RunComfy. All Rights Reserved.

RunComfy is the premier ComfyUI platform, offering ComfyUI online environment and services, along with ComfyUI workflows featuring stunning visuals. RunComfy also provides AI Models, enabling artists to harness the latest AI tools to create incredible art.

OpenKatana · Process clip