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 · Render page

ComfyUI Node: OpenKatana · Render page

Class Name

OpenKatana_render_page

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 · Render page Description

Renders local web animations into reproducible PNG frame sequences for OpenKatana timelines.

OpenKatana · Render page:

OpenKatana_render_page turns a locally hosted web page into a sequence of PNG frames for use as an animation clip in an OpenKatana timeline. It supports artwork built with HTML, CSS, SVG, or Canvas, making it useful for rendering procedural graphics, animated typography, diagrams, and other browser-based visuals. The renderer uses a headless browser, meaning no visible browser window is needed, and captures each frame at an explicitly calculated animation time rather than recording real-time playback. To check that the artwork renders consistently, it compares selected frames rendered in forward and reverse order before capturing the complete sequence. Random numbers are seeded separately for each frame to support repeatable results, while network restrictions keep the page from loading resources outside the local project server. This approach helps you create reproducible animation assets with a record of the page, clip settings, and rendering checks.

OpenKatana · Render page Input Parameters:

project_id

A required STRING identifying the OpenKatana project associated with the tool call. The node passes this value into its argument-preparation helper together with the tool name and the argument text, so you should supply the identifier for the project containing the page and its related assets. The supplied code does not show how project identifiers are created, validated, or translated into project folders, so do not assume that an arbitrary folder path can replace the identifier. No default value, length limits, or predefined options are specified in the provided interface.

arguments

A required STRING containing the tool-call arguments that are processed before the page-rendering tool is invoked. This is the node’s argument-text input, not a separate socket for each rendering setting. The underlying rendering function accepts a project root, page, output location, and optional frame-count, frame-rate, and determinism-sample settings; however, the supplied wrapper does not expose the exact serialized argument schema or show which values are supplied automatically. Use the render-page tool’s documented argument format rather than assuming that the Python function signature can be copied directly into this field. For context, the renderer validates page width and height as integers from 16 to 7680 pixels, frame rate from 1 to 240, and frame count as an integer from 1 to 36000; frame rate and frame count use the page’s declared values when no effective override is provided, and the underlying determinism sample count defaults to 5. These are renderer settings, not additional node inputs. No default text, string-length limits, or selectable options for arguments are shown in the provided interface.

after

An optional STRING accepted by the node’s execution method, with a Python default of None when omitted. In the supplied implementation, this value is not referenced inside the method or explicitly forwarded to the tool invocation, so the visible code does not establish any effect on rendering, output content, or execution order. Do not rely on it to delay rendering or establish a dependency without additional documentation for the surrounding OpenKatana system. No supported string format, length limits, or predefined options are specified.

OpenKatana · Render page Output Parameters:

result_json

A STRING containing the tool response after it has passed through the node’s response-formatting helper. On a successful render, the underlying renderer returns a receipt containing page, page_sha256, clip, determinism_sample, blocked_requests, and time_basis, and also writes that receipt to page-render.json in the render output directory. The clip describes the image sequence through frames_dir, a project-relative folder path; pattern, set to %05d.png for filenames such as 00000.png; n, the frame count; fps, the frame rate; and w and h, the dimensions in pixels. The page hash identifies the source page used for the render, the determinism sample lists the frame indices checked for repeatability, and the blocked-request information records intercepted requests and reported security-policy violations. The time basis states that each frame uses t = f / fps. This output is response text rather than a ComfyUI image batch or video file; the exact outer response structure is not shown because the response-formatting helper is not included.

OpenKatana · Render page Usage Tips:

  • Prepare the page with the required contract: window.openkatanaPage = {width, height, fps, frames, render(t, f)}. Its rendering method should draw the complete visual state for the requested time and frame index. The implementation also accepts window.hfPage as a fallback, but the documented name is window.openkatanaPage.
  • Calculate animation positions, opacity, and other visual properties from t or f instead of relying on elapsed real time, playback timers, or accumulated changes from earlier frames. The renderer deliberately requests sample frames in both directions, so each frame must work independently of the order in which it is requested.
  • Keep images, scripts, fonts, and other resources on the local project server. Remote fonts, CDN libraries, and externally hosted images cannot be relied on because requests outside that server are blocked.
  • Start with a small page resolution and short frame count when checking a new design. Once the composition and repeatability checks pass, increase them for the final render; capturing fewer, smaller screenshots generally reduces rendering work.
  • Choose frame rate and frame count together. For example, 120 frames at 24 fps represents a five-second clip, with captured frame times running from 0 through 119/24 seconds. Configure these values in the page contract or through supported tool arguments, staying within the renderer’s validated limits.
  • Use the seeded Math.random when you need repeatable random variation during frame rendering. Its seed resets before each requested frame, but this does not make other sources of changing state—such as the current clock or persistent counters—repeatable.
  • Remember that screenshots are taken with browser animations disabled. For predictable motion, explicitly set the page’s visual state for each requested frame instead of expecting ordinary CSS animation playback to advance the artwork.
  • Inspect the returned receipt before using the clip in a timeline. Confirm its dimensions, frame rate, frame count, and frame folder, and review blocked_requests if fonts, images, or other visual elements appear missing.

OpenKatana · Render page Common Errors and Solutions:

<page>: the page must define window.openkatanaPage = {width, height, fps, frames, render(t, f)}

  • Explanation: The loaded page does not expose the expected page object with a callable render method. This can happen when the contract is missing or when a script error prevents the page from defining it.
  • Solution: Define window.openkatanaPage with the required dimensions, timing values, and rendering method. Check that the page’s scripts load successfully and that the object exists when the renderer inspects the page.

<page>: not deterministic — frames <indices> differ when rendered in reverse order

  • Explanation: One or more sampled frames produced different PNG data depending on the order in which they were rendered. The renderer stops rather than accepting a sequence whose appearance depends on previous rendering calls.
  • Solution: Make each frame calculate and draw its complete state from t and f. Reset any accumulated drawing state, clear Canvas content where appropriate, and avoid clock-based animation, persistent counters, or resources that change between captures.

Invalid page dimensions

  • Explanation: Width and height must each be integers from 16 to 7680 pixels. Missing or unsuitable values can fail conversion or validation before frame capture; the exact validation error text is not included in the supplied code.
  • Solution: Set both width and height on the page object to whole numbers within the supported range, such as 1920 and 1080. Avoid CSS dimension strings such as "1920px" for these contract values.

Invalid frame rate or frame count

  • Explanation: The renderer requires a frame rate from 1 to 240 and an integer frame count from 1 to 36000. Missing, nonnumeric, or out-of-range effective values can prevent rendering; the exact validation message is not shown.
  • Solution: Supply valid page-level fps and frames values, or valid overrides through the supported tool argument format. Use a positive whole number for the frame count and check that both settings remain within their allowed ranges.

unexpected inputs: <names>

  • Explanation: The node explicitly raises this error if extra keyword fields are supplied that are not recognized by its typed input definitions. Internal renderer settings are not automatically available as node sockets.
  • Solution: Use only the listed node inputs: project_id, arguments, and optional after. Put supported tool settings into arguments according to the tool’s argument schema rather than adding new inputs.

Security-policy violations in blocked_requests

  • Explanation: The receipt can contain content-security-policy reports or blocked network requests when the page tries to access disallowed resources. These entries are not necessarily fatal errors, but the resulting artwork may be incomplete.
  • Solution: Move required resources into the project and reference them through the local project server. Avoid remote CDN dependencies and inspect the reported blocked addresses or policy directives to identify missing assets.

Page-script or rendering-method failure

  • Explanation: The renderer executes the page’s rendering method in the browser for both sampling and final capture. A JavaScript exception during that call can interrupt rendering; its exact message depends on the page code, and no fixed page-render error wrapper is shown.
  • Solution: Check the page’s JavaScript for missing elements, unavailable assets, and undefined variables. Test the rendering method at frame 0, a middle frame, and the last frame, ensuring that each call can draw successfully without needing earlier calls.

OpenKatana · Render page 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 · Render page