Jingyuma Storyboard

The step nobody wants to do by hand

Illustrating a story means turning prose into shots. You paste the chapter into ChatGPT, ask for a shot list, strip the markdown preamble, then copy shot 7 into the prompt box - a 2026 workflow writeup on r/StableDiffusion mentions "I use ChatGPT to generate the shot list + prompts" in passing. It works, and it's twenty minutes of copy-paste before your GPU does anything.

Jingyuma Storyboard (镜语马, from shotstory.cn) is that step as a node. Paste the text, and four strings come out: image_prompts, video_prompts, dialogues, raw_json. Wire image_prompts into a CLIP Text Encode and you have a graph that runs chapter → image.

One thing to get straight: this node runs no model. No checkpoint, no weights, nothing on your GPU. It POSTs your text to https://shotstory.cn and hands back what the server wrote. So the honest comparison is this vs. a browser tab - or vs. a local prompt-enhancer LLM plus homemade shot-splitting logic. Convenience and a purpose-built engine, against a key, credits, and your manuscript leaving the machine.

What's actually going over the wire

The mechanism is simple. It posts JSON to /api/v1/generate with your key in an X-API-Key header, a 120-second timeout, and a payload of {text, mode} - plus mood or theme only when the mode calls for it. Server errors arrive as readable messages - bad key, no credits, plan gate, rate limit.

The response's shots array gets flattened into lines. Each shot becomes [Shot 001] <visual_description>, which is why the companion Split Shots node can find shot 3 by number.

Two things the README glosses over. image_prompts and video_prompts are the same text in v1.0.2 - both get the shot's visual_description, so there's no separate camera-motion language for a video model. And raw_json isn't the server's full response; it's a locally re-serialized subset per shot (index, original_text, dialogue, duration, visual_description, is_violation, review_token). Still where the good stuff lives: original_text is the field Refresh Shot wants.

Shots the server flags as violations don't break the run: they come back as [Shot 003] Content blocked (violation), and the Chinese 无 in dialogues is normalized to (no dialogue).

Inputs and outputs worth touching

text and api_key are required; everything else is optional. text is capped at 10,000 characters; the node raises before spending a credit if you're over.

mode is the one setting that matters, and it's a paywall in disguise:

• basic - fast, free tier, no emotion or genre layer
• mood - Standard plan and up
• theme - Pro

mood (ten options, default "(not set)") and theme (twenty-one genres, default "(auto detect)") only apply when their mode is selected; "(auto detect)" lets the server guess the genre.

use_cache defaults on: an in-process dict keyed on an md5 of text|mode|mood|theme, 10-minute TTL.

Of the four outputs you'll wire image_prompts almost always. dialogues is for subtitles or TTS. raw_json is for reading, and for feeding original_text into Refresh Shot.

Install

ComfyUI Manager: search Jingyuma Storyboard (publisher huchengAI). Or by hand:

cd ComfyUI/custom_nodes/
git clone https://github.com/huchengAI/comfyui-jingyuma-storyboard.git
cd comfyui-jingyuma-storyboard
pip install -r requirements.txt

Restart. The only dependency is requests - no models, no CUDA. Nodes show up in the Jingyuma category (search 镜语马). The repo ships two example workflows in workflows/; drag the JSON onto the canvas. If it complains about a missing PreviewText node, update ComfyUI or delete them.

Then the key: register at https://shotstory.cn/?register=1 with a phone number and SMS code - the key is copied to your clipboard. Signup gives 100 credits, daily check-in 300 more, and free credits expire at midnight, so don't plan around them. Billing is 1 character = 1 credit: a 5,000-character chapter costs 5,000 credits each time the node runs.

Where people get burned

Fewer shots than you asked for, or a 403 that isn't about your key. The free tier caps a generation at 10 shots (basic 100, standard 500, pro 1000), so a long chapter comes back truncated rather than erroring. And a 403 is the plan gate: mood on the free tier, or theme without Pro.

Timeouts and odd characters. 120 seconds is generous for a paragraph and not for 10k characters from a server in China - split long input. If the outputs come back as mojibake, the README pins it on Python < 3.8 or a non-UTF-8 locale.

Repeat runs are cheap, then aren't. ComfyUI only re-executes a node whose inputs changed, so cycling shots downstream won't re-bill you. Change the text or the mode and it calls the API again - a fresh charge, cache or no cache.

And the standing caveat for any API-wrapper node: it holds a credential and calls the network by design, so read it before you run it. Here that's ten minutes - one file, one dependency.