Higgsfield ships a bundled video-explainer workflow through its MCP server: hand it a script and it produces a narrated, animated video by generating one 10-second clip per line, voicing each line, and stitching the result into a single MP4. This guide runs that workflow from Claude Code, using a short made-up script so you can see exactly how a few lines of text become finished clips.

Claude Code is a good fit here because the whole flow is text-driven. Every visual is generated from a written style description and per-block prompts, so there are no local files to upload — the terminal client never needs to render an upload widget. You paste a script, answer a few setup questions, and Claude Code orchestrates the Higgsfield tools for you.

Generation is paid: rendering clips and voice takes reserves Higgsfield credits. The script phases (writing the narration and the shot prompts) are free, so you can draft the whole thing and price it before spending anything.

What you will do

  1. Add the Higgsfield MCP to Claude Code and authenticate.
  2. Give Claude Code a script and the video settings.
  3. Watch it lock a visual style key, then write narration and shot prompts.
  4. Preflight the credit cost.
  5. Generate the clips and the per-line voiceover.
  6. Let it assemble the final MP4 and hand you the file.

Prerequisites

  • A Higgsfield account with credits (higgsfield.ai). No API key is needed; the connector authenticates through your account.
  • Claude Code installed and signed in.
  • A script for a short, narrated, non-photoreal video — flat 2D, ink, painterly, silhouette, and the like. The workflow is built for animated explainers and narrated stories, not filmed footage with real actors.

Step 1: Add the Higgsfield MCP to Claude Code

Higgsfield runs a hosted MCP server over HTTP, so you add it as a remote server and authenticate with OAuth.

claude mcp add --transport http higgsfield https://mcp.higgsfield.ai/mcp

Start a Claude Code session and run the MCP command to authenticate:

/mcp

Pick higgsfield, complete the browser sign-in with your Higgsfield account, and the tools become available. Confirm the link with a read-only call that spends nothing:

Using Higgsfield, what’s my credit balance?

That runs the balance tool and prints your remaining credits.

Step 2: Hand Claude Code the script and settings

The workflow measures length in blocks: one block is one 10-second clip, one narration line, and duration_minutes × 6 blocks total. A 30-second video is three blocks. Here is the made-up script this guide uses — a three-line micro-story:

Block 1
For thirty years the old mapmaker drew coastlines and rivers, but at the
ragged edge of every map he left a wide, empty margin.
Block 2
Apprentices begged him to fill it with sea serpents and warnings, the way the
other guilds did. He always refused, and never explained.
Block 3
On his last night he finally spoke. The blank edge, he said, is not ignorance.
It is an invitation to go and look.

Each line is around twenty words, sized to land in roughly eight to nine seconds of speech so it sits centered in the fixed 10-second block. Kick it off:

Make a narrated explainer video from this script with Higgsfield. Thirty seconds, three blocks, English narration, faceless (no mascot), 16:9. Here’s the script: [paste the three blocks above]

The workflow asks before generating (its Phase 0). Expect Claude Code to confirm the visual style, duration, language, whether there is a recurring mascot, aspect ratio, and whether you want burned-in subtitles. In a rich client it shows a style gallery; in Claude Code’s terminal you just describe the look you want. For this story, answer with a style:

Style: hand-inked black marker on off-white paper, strictly monochrome. No subtitles.

Step 3: The style key and the prompts

Two free, text-only phases happen next.

The style key. The workflow writes a reusable STYLE descriptor and generates one reference image that locks the look, using generate_image with the nano_banana_pro model. For this story the descriptor is:

hand-inked black-marker on off-white paper, solid jet-black fills, thin white
scratch highlights, marker grain, strictly monochrome,
non-photorealistic, illustrated, not a photo, no live-action, no realism

That image’s job id is attached as the image reference on every clip, which is what keeps all three blocks in one consistent style. The image’s aspect ratio also sets the video framing (16:9 here), so the clips inherit it automatically.

The block prompts. For each block the workflow writes a labeled video prompt that pins the style, describes the scene for that line, sets the camera motion, and allows ambient sound only — never spoken words, because the narration is added later. Block 1 looks like this:

Block 1
STYLE REFERENCE: Match the attached reference image EXACTLY: hand-inked black
marker on off-white paper, solid jet-black fills, thin white scratch highlights,
marker grain, strictly monochrome.
SCENE: An old mapmaker bent over a wide sheet, inking a coastline; the far edge
of the map stays a broad blank margin.
MOTION: Slow push-in toward the empty margin, ink lines settling.
AUDIO: quiet scratch of a nib, soft room tone — no voice.
NEGATIVE: color, gray midtones, photorealism, 3D render, lip-sync, captions,
on-screen text, watermark.

Blocks 2 and 3 follow the same shape for their own lines. Nothing is spoken inside any clip; the AUDIO line is sound design only.

Step 4: Preflight the cost

Before rendering, ask for an estimate. Each generation tool can price a job without submitting it:

Before generating anything, estimate the credits: one style-key image, three ten-second clips, and three voice takes.

Behind that, Claude Code calls each tool with get_cost: true. On the review date, a single 10-second clip (gemini_omni, 720p) priced at:

{ "cost": { "credits": 30, "credits_exact": 30 } }

and one Seed Audio narration take at:

{ "cost": { "credits": 0.4, "credits_exact": 0.4 } }

So this three-block video is roughly 90 credits for the clips plus about 1.2 credits for the three voice takes, plus the one style-key image (preflight it the same way, since image cost varies by model and resolution). Assembly in Step 6 is free. Optional subtitles add 0.05 credit per voiced block. Re-run the estimate for your own length rather than assuming the rate holds — a two-minute video is twelve blocks, not three.

Step 5: Generate the clips and the voiceover

Approve the spend and let it render:

Looks good — generate the clips and the voiceover.

Two things happen, both paid and asynchronous:

  • Clips. The workflow submits one generate_video job per block with model: gemini_omni, duration: 10, resolution: 720p, and the style-key job id attached as the image reference. It polls job_status until each clip is done and saves the result URL.
  • Voiceover. It calls list_voices and asks you to pick the narrator — choose one voice id and it reuses that same voice for every line so the narrator stays identical. Then it voices each block with generate_audio using the seed_audio model, one take per line.

Because each generation returns a job id you poll, a longer script just means more jobs; the pattern is the same at three blocks or sixty.

Step 6: Assemble the final video

The workflow assembles automatically once the clips and voice takes are ready — you should not have to ask. It calls the explainer_video tool with the blocks in order, each pairing a clip with its voice take:

explainer_video
  params:
    width: 1280
    height: 720
    items:
      - { video: "<clip 1 job id>", audio: "<voice 1 job id>" }
      - { video: "<clip 2 job id>", audio: "<voice 2 job id>" }
      - { video: "<clip 3 job id>", audio: "<voice 3 job id>" }

Every block is a fixed 10 seconds: a shorter voice take is centered with silence padded around it, a slightly longer one is sped up pitch-safely, and the video is never stretched. The total lands at exactly N × 10 seconds. If you had turned subtitles on, a subtitles block with your chosen font would go here and the backend would transcribe the finished voiceover and burn timed captions server-side.

Assembly returns one job id; Claude Code polls job_status and hands you the final MP4 URL. Download it and upload to YouTube as usual.

Getting good results

  • Keep it non-photoreal. The workflow refuses realism by design. If a clip drifts toward a photo look, strengthen the STYLE line and the NEGATIVE list; two identical failures mean the prompt is wrong, not the luck.
  • One clear action per block. Each 10-second clip should show a single beat that matches its narration line. Busy scenes read as noise at this length.
  • Size lines to the block. Aim each narration line at eight to nine seconds (about twenty to twenty-four words). A big overrun needs a shorter line and a re-voice; a small one the assembler handles.
  • Reuse the style key and the voice. The same style-key image on every clip and the same voice id on every line are what make the video feel like one piece.
  • Draft free, then commit. Iterate on the script and prompts (free) until you are happy, and only then approve the paid render.

Troubleshooting

  • /mcp shows Higgsfield as unauthenticated. Re-run /mcp, select higgsfield, and finish the browser sign-in; the tools stay greyed out until OAuth completes.
  • It skipped asking about style or mascot. That is a workflow requirement, so prompt it: “Ask me the setup questions first.” Answer style, duration, character, aspect, and subtitles before generating.
  • A clip came out photoreal. Regenerate that block with a stronger non-photoreal STYLE descriptor and a fuller NEGATIVE list; the style key holds the look across the rest.
  • Narration runs long. Shorten the block’s line or raise speech_rate, then re-voice just that block. The block window is a fixed ten seconds.
  • Not enough credits. Check balance and re-run the get_cost preflight for your real block count before approving the render.

Recap

A script becomes a video in six moves through Claude Code: connect the https://mcp.higgsfield.ai/mcp server, hand over the script and settings, let the workflow lock a style key and write per-block prompts, preflight the credits, generate one 10-second clip and one voice take per line, and let it assemble the blocks into a single MP4. You write the words and pick the look and the voice; Higgsfield renders and stitches, and Claude Code drives the tools.