BytePlus Image Quality Enhance

Upscaling is the one job where the local stack is genuinely split. A GAN upscaler (Real-ESRGAN and friends) is fast, predictable and adds nothing you didn't ask for - and it can't invent the detail that isn't there. A diffusion-style restorer like SeedVR2 or SUPIR can rebuild texture, but it also invents faces and invents text, and on a soft source you end up with a plausible lie. This node sits on the other side of that tradeoff: BytePlus's AI MediaKit performs super-resolution, denoising, deblurring and sharpening as a hosted call, and for AIGC post-processing, old-photo restoration or OCR input it will often beat what you'd get locally in one pass.

The honest caveat first: this is a paid API call and your image leaves your machine. It's the wrong tool for anything the closed model would refuse, and it's the wrong tool if you'd rather own the pipeline. It's the right tool when the alternative is a four-node local chain you have to babysit.

How it works

There's no sampler here and nothing to download. A connected image is encoded and uploaded to Comfy.org storage (needs a Comfy.org login), then MediaKit's synchronous enhance-image endpoint does the work and returns a URL, which the node downloads immediately - MediaKit links expire after 24 hours, so the node can't just hand you a link and walk away. A batch is processed per image, in parallel, and the results are restacked into one tensor; if the enhanced images come back at different sizes, later ones are resized to match the first so the batch survives.

The two inputs you actually set

• tool_version is the whole decision. standard does fast clean-up at up to 8x and always returns PNG - thumbnails, UGC, OCR input. professional goes up to 30x with fine texture, for AIGC fixes, product and portrait shots, old photos. max is a generative model at up to 30x for badly degraded sources, and it's the slow one. Pick professional or max and two extra fields appear: generative_enhance_mode (generative_first for richer texture on compressed or blurry images, fidelity_first to keep faces, text and texture close to the original) and, on max only, enable_correct_color. The README is explicit that pricing differs per version, so max on a batch of fifty is a budgeting decision.
• output_size chooses between scaling by a multiple (default 2x) or naming a target_width / target_height. Limits are checked before upload, which is the behaviour you want: you find out immediately instead of after a 30x bill.
• image or image_url - one or the other. The URL path is a public http(s) link to a png/jpg/jpeg/webp under 10 MB, and it skips the Comfy.org upload completely.

Outputs are IMAGE (the enhanced result), original (your input resized to the enhanced size) and response (MediaKit's JSON). The original output exists for one reason: feed it and IMAGE into ComfyUI's Compare Images slider and you can see what actually changed instead of squinting.

Install and key

cd ComfyUI/custom_nodes
git clone https://github.com/byteplus-sa/ComfyUI-BytePlus-ModelArk
pip install -r ComfyUI-BytePlus-ModelArk/requirements.txt

Restart (ComfyUI 0.31.0+), or install from Manager by searching BytePlus ModelArk. MediaKit has its own key, separate from the ModelArk key - create it in the AI MediaKit console and save it in Settings → BytePlus, or as BYTEPLUS_VOD_MEDIAKIT_API_KEY in user/.env. MediaKit runs in ap-southeast-1 only, so don't bother switching region for it.

Where people get burned

The Comfy.org login catches everyone who connects a local file the first time. If you don't want to log in, host the image and use image_url.

Then there's the conceptual trap: people wire this in expecting a general-purpose upscaler for generative output. It is very good at restoration - softening artefacts, recovering text, cleaning a JPEG - and it isn't a detail-invention engine the way a diffusion upscaler is. There's also a warning in the pack's own logging when max gets a large source: it's slow, and the recommendation is to keep sources sensible rather than throwing an 8K scan at it. For source material whose damage is the actual problem rather than its size, the local SeedVR2 + edit-model recipe is still cheaper per call; this node wins on one-pass convenience and on not knowing how to upscale at all.