Get Vocal Separation Details

What it's for

Vocal separation is the step that turns a finished track into usable pieces: the voice on its own, the backing on its own. Karaoke versions, acapella sampling, remixes, replacing a chorus - all of it starts here. On Suno it's an API task, and this node reads that task's record back.

That matters more than it sounds. Suno's output is a finished song, and a finished song is a dead end for a lot of production work - you can't drop the drums out, you can't pitch the vocal, you can't restructure the arrangement. Separation is what makes a generated track editable.

So the practical shape is a chain: generate the song, separate it, then branch. Vocals to a melody-extraction or MIDI step, instrumental to a backing-track or mixing step. This node is the "did it finish, and where are the files" link in that chain.

It's a read. No separation happens here, nothing is billed, and no audio is uploaded.

How it works

The node queries the task record through the pack's authenticated KIE client. The pack's status reader follows Suno's convention: it reads a status field off the response data, treats SUCCESS as done, and raises a KIE API error on the terminal failure states (CREATE_TASK_FAILED, GENERATE_AUDIO_FAILED, CALLBACK_EXCEPTION, SENSITIVE_WORD_ERROR, FAILED), so a botched job surfaces as the provider's own message instead of an empty output.

Worth knowing about the pack's organisation here: these Suno utilities are grouped by function rather than by strict API page, so the MIDI node lands under Vocal Removal too. If you go hunting in the node menu for "where's the separation chain," that's why the neighbourhood looks the way it does.

And the standard input caveat for this family: KIE's docs page for this record endpoint carried no machine-readable request schema when the pack built its catalog from KIE's documentation index, so the node came out of the fallback generator with placeholder fields. The pack re-resolves such pages on demand, so a UI reload can bring real fields in later.

Inputs and outputs

No required inputs. Optional:

• timeout_seconds - INT, default 1200, min 30, max 7200, step 30. The pack's wait budget for the request.
• expert_override_json - STRING, default {}, described by the pack as "expert-only payload overrides for APIs whose documentation has no request schema yet." On a GET-shaped node these keys go out as query parameters, so the task ID belongs here - {"taskId": "…"}. Empty override, no query.

If the placeholder inputs of some sibling nodes bother you, note this one simply has none - which is arguably less confusing, but the same rule applies: the override is what does the asking.

Outputs: audio (AUDIO), url, all_urls_json, task_id, raw_json (STRING), credits_consumed, credits_left (FLOAT). A separation result is plural by nature - vocals and instrumental - so all_urls_json is the socket that stops you guessing; raw_json holds the full record, and url gives you the first extracted link.

Installing

cd ComfyUI/custom_nodes
git clone https://github.com/felipederosilva/ComfyUI-KIE-Nodes-Next
pip install -r ComfyUI-KIE-Nodes-Next/requirements.txt

Restart ComfyUI, then set your key once at Settings → KIE.ai Nodes Next → Connection. The pack validates the key against KIE before saving and shows only a masked fingerprint afterwards; the stored credential lives in ComfyUI's user config directory rather than in your workflow JSON. Headless servers can export KIE_API_KEY instead - it takes priority over anything saved locally.

The requirements are requests, Pillow, numpy and PyYAML, so there's effectively nothing to install beyond the pack itself: no weights, no GPU, no CUDA. Windows users can run the one-click installer in dist/ to have the folder placed for them.

Where people get burned

Separation tasks are slower than you expect if your mental model is "it's just splitting a file" - there's a model doing the work server-side. Query too early and you get an in-progress record that reads like a failure.

The multi-output thing trips people up next. A separation job returns more than one artifact, and if you wire url alone you'll get whichever came first and then wonder where the other half went. Look at all_urls_json or raw_json and route deliberately.

And if you're doing this locally instead: the open ecosystem has separation tools that run on your own machine, which removes the per-call cost and the upload. People reach for the API version when they're already in a Suno pipeline; they reach for local when the audio is something they don't want to send anywhere. Both positions are reasonable - just know which one you're in before you wire it.