Video walkthroughs · Claude Code Club

How To Connect Higgsfield To Claude Code With MCP

15 minute read · Companion guide to “One Product Photo, 12 Prompts, A Full Brand Campaign With Claude Code”

There is a version of connecting a generation tool to Claude Code that takes a minute and works forever, and a version where you spend an afternoon confused about why nothing is being called. The difference is knowing which of the two install paths applies to you, and knowing that the connector being installed is not the same thing as the connector being switched on. This guide covers the connection precisely, then the part nobody warns you about: how a single campaign prompt turns into fifteen video generations at the most expensive setting available.

Watch the full build: one product photo to a complete brand campaign

What the MCP connection actually gives you

MCP stands for model context protocol. You do not need to care what the letters mean. What it means in practice is that Claude Code can talk directly to Higgsfield, so anything you can reach in the browser becomes reachable from your terminal: the image models, the video models, the audio models, the editing tools, all of it.

The reason that matters is not convenience. It is that the prompt writing moves. When you generate in a browser, you are the one typing the prompt into the box, and your prompt is limited to what you personally know about lighting, lens, surface, and composition. When the generator is connected to Claude Code, Claude writes the generation prompt, and it writes it with the full context of everything already in the session: the product brief, the competitor research, the color palette, the master image it produced ten minutes ago. The prompts it produces are more specific than the ones most people would write by hand, because they are built from a document rather than from memory.

That is the whole argument for doing creative work this way. The generation quality is the same either way. The briefing quality is what changes, and briefing is most of the job.

Step 1: Pick MCP or CLI, because they are not interchangeable

Higgsfield ships two integration paths and the right one depends entirely on where you run Claude Code.

• Claude Code inside the Claude desktop app: use the MCP. The desktop app has a connectors interface built for exactly this, and the connection persists across sessions and folders.
• Claude Code in a terminal or an IDE like VS Code: use the CLI. The MCP route is built around the desktop connector UI, so in a terminal you are fighting the tool rather than using it.

Get this wrong and the symptom is not a clear error. It is a session where Claude describes the image it would generate, in convincing detail, and never calls anything. Check which surface you are on before you start, not after.

Step 2: Add Higgsfield as a custom connector

This is the whole install. It runs once and takes about a minute. The MCP URL is on the Higgsfield MCP and CLI page, alongside the same instructions.

1. Copy the MCP URL from the Higgsfield MCP and CLI section.
2. In Claude Code, open settings and click the plus, then go to connectors.
3. Click manage connectors, then the plus at the top, then add custom connector.
4. Name it Higgsfield, paste the URL into the URL field, and click add.
5. Sign in with your Higgsfield account when the authorization prompt appears.
6. When the first tool call asks for permission, choose always allow so you are not approving every single generation by hand.

Then verify, because installed and active are two different states. Click the plus, go to connectors, find Higgsfield in the list, and confirm the toggle is on. A connector that is added but toggled off looks completely normal in the settings list and does absolutely nothing in a session.

Step 3: Say the tool name in the prompt

A connected tool is available, not mandatory. Claude will happily answer a creative prompt with a written description of an image rather than an actual image, especially early in a session before any generation has happened.

The fix is one phrase. Open the prompt with using Higgsfield and the call gets routed. It looks redundant. It is the difference between a folder full of PNGs and a chat log describing PNGs. Once the first generation has landed in a session, later prompts usually route on their own, but there is no cost to being explicit every time.

One more setup choice worth making before a long run: switch to the stronger model. A campaign chain is a long multi-step task with dependencies between the steps, where a decision made in step two constrains step nine. That is exactly the shape of work the larger models are built for, and the difference shows up as brand consistency rather than as prettier prose.

Step 4: Build the brief before you generate a single pixel

Now the connection is live, and the temptation is to immediately generate something. Do not. The first three prompts of a good run produce no images at all, and they are the reason the images that follow look like they came from one brand.

Prompt one turns the product photo into a brief. You drop the photo into the folder and ask Claude to act as a brand strategist and fill out a structured brief from what it can actually see. The instruction that carries the weight is the constraint: do not invent features, only state what is visually confirmable. Without it you get a brief full of plausible marketing claims that the product does not support, and every asset downstream inherits the fiction.

A good brief comes back with the product name, a one-line pitch, the brand promise, a handful of proof points, the extracted color values, the mood, and the buyer profile. In the walkthrough the product was a lens cleaner for glasses, chosen deliberately because it is not a glamorous object. The brief came back with a pocket-sized precision spray that strips smudges and oils without streaking or scratching, aimed at practical tech-forward glasses wearers between twenty-five and forty-five. None of that was supplied. All of it came from one photo.

Step 5: Make it do the research nobody wants to do

Prompt two is the one that decides whether the campaign says anything true. It takes the brief and goes looking for what real buyers complain about, across TikTok, Reddit, the open web, and the Meta Ad Library, which is free and public and shows you the actual ads competitors are running right now.

Ask it for four things specifically:

• The unresolved problem in the category that is worth attacking.
• The top three competitor positioning angles, so you know which lanes are already crowded.
• Any proof point from your brief that the research does not support, flagged for removal.
• Stronger proof points or gaps the brief missed entirely.

That third item is the one people leave out, and it is the most valuable. It turns the research pass into a fact check on your own brief rather than a pile of confirming evidence. In the lens cleaner run it surfaced a problem the brief had no idea about: buyers cannot tell which sprays are actually safe for anti-reflective and blue-light coatings, and there are Reddit threads full of people who found out the expensive way. Three competitor angles were already taken, streak-free clarity, safe for all coatings, and wiping damages your lenses. The coating-safety anxiety was the open lane.

Step 6: Lock the design system once, reuse it forever

Prompt three converts the brief and the research into a design definition: primary and secondary taglines, brand voice rules, the color palette with real values, and typography. It takes seconds and it is the file you will still be using six months from now.

This is the part most people underrate. The campaign you are building today is one consumer of that definition. The landing page, the email sequence, the next product drop, and every ad variant after it are all consumers too. You are not making a campaign, you are making the source file a campaign is compiled from. Save it. Name it clearly. Point future sessions at it instead of rebuilding it.

Step 7: Generate one master image and make everything reference it

Here is the idea in this whole workflow that generalizes furthest past the demo, and it is worth more than the connection instructions. Do not generate ten images from ten prompts. Generate one master image, get it right, and then generate everything else with that image as the reference.

Ten independent prompts describing the same product produce ten slightly different products. The label drifts. The cap changes shade. The proportions move. It is invisible in any single image and glaring the moment two of them sit side by side in a carousel. Referencing a master image collapses that variance, because every subsequent generation is anchored to one artifact rather than to ten separate readings of a text description.

So the master shot gets the treatment nothing else gets. Use a photoreal model. Specify the surface, the lighting, the exact colors from the design definition, the wordmark and any on-pack text. Then add the step that most people skip: have Claude run a vision analysis on its own output and check it against the brief before moving on. It looks at the returned image, compares it to what was asked for, and reports what is off. Catching a wrong label color here costs one regeneration. Catching it after the brand kit costs eleven.

Step 8: Fan out the image kit from the master

With the master locked, one prompt produces the full kit, each image referencing the master and the design definition. The set worth asking for covers the places a brand actually has to appear:

• A clean centered pack shot, the workhorse for listings and thumbnails.
• A three-variant flatlay, which shows range even before the range exists.
• A close-up with a human element, because product-only sets read as sterile.
• A billboard hero with a copy lockup, which forces the tagline to survive at large scale.
• A vertical reels cover sized for social.
• A surreal floating composition, the one that gets saved and shared.
• A merch or accessory flatlay, an in-context lifestyle frame, an unboxing shot, and a color system chart for whoever builds the site.

Ten is the right number for a first run. Enough to see whether the brand holds together across contexts, small enough that regenerating the two that missed is not painful.

Step 9: Understand the video math before you send the prompt

Video is where the credits go, and the reason is arithmetic rather than price gouging.

Ask for five videos, a UGC pain reveal, a cinematic flagship, an ASMR unboxing, a POV demo, and a surreal product hero, and you have not asked for five generations. Each finished video is assembled from three clips of roughly ten seconds and stitched together. Five videos is fifteen generations, and by default the plan will be to run every one of them at full 1080p.

Three parameters control the bill, and all three are reachable through the MCP by simply stating what you want in the prompt:

• Resolution. Dropping from 1080p to 720p roughly halves the cost. Going to 480p cuts it further. On a phone-sized feed, 720p is frequently indistinguishable.
• Clip length. Anywhere from four to fifteen seconds. Most social cuts do not need ten-second constituent clips, and shorter clips also fail cheaper when a prompt misses.
• Clip count per video. Three clips stitched is a default, not a law. A single well-composed clip is often the whole asset.

The discipline that keeps this sane is the same one that applies to any generated asset: quality tier should scale with how much screen the asset occupies and how long anyone actually looks at it. The hero video on the landing page gets 1080p and the best model. Fifteen seconds of B-roll behind a text overlay in a reel does not. Decide the tier per asset in the prompt, before the run starts, rather than watching the credit counter and panicking halfway through.

Step 10: Package the output so it can leave your laptop

The last prompt in the chain is the least glamorous and the one that makes this usable with other people. Ask for a single master PDF: a cover page, the brand book, the research summary, and every asset laid out in order.

A folder of files is a personal artifact. A document is something you can send to a client, hand to a freelancer, or review yourself in a week when you have forgotten why the palette is what it is. The packaging step is what turns a generation run into deliverable work, and it takes seconds because everything it needs is already in the session.

The failure modes worth knowing before your first run

Each of these costs either credits or a rerun, and all of them are avoidable in advance.

• Using the MCP path from a terminal, or the CLI path from the desktop app. The symptom is silence, not an error.
• The connector added but toggled off. It looks correct in the settings list.
• Not choosing always allow, so a long batch stalls on approval the moment you step away.
• Not saying the tool name, so Claude describes an image instead of generating one.
• Generating before the brief and research exist, which produces good-looking assets with nothing to say.
• Ten independent prompts instead of one master plus nine references, which quietly destroys product consistency.
• Skipping the vision self-check on the master, so every flaw is reproduced across the whole kit.
• Leaving resolution and clip length unspecified on video, which is how fifteen 1080p clips get generated in one unattended pass.
• Working in a bare folder, so nothing accumulates and later prompts have no context to build on.

Run your first campaign in one sitting

The shortest honest path from finishing this guide to having real assets. Use a product you already own and photograph it on a plain surface. Pick something unglamorous on purpose, because a system that makes a boring object look good will make anything look good, and you will trust the output afterwards.

1. Make a project folder, drop the product photo in it, and start Claude Code inside that folder.
2. Add the Higgsfield custom connector, sign in, choose always allow, and confirm the toggle is on.
3. Run the brief prompt with the do-not-invent constraint, and read what comes back against the actual photo.
4. Run the research pass across social, the web, and the Meta Ad Library. Delete any proof point the research contradicts.
5. Lock the design definition: taglines, voice rules, palette, typography. Save it as the file future work points at.
6. Generate the master image with a photoreal model, then have it vision-check its own output before you continue.
7. Fan out the ten-image kit, every image referencing the master and the design definition.
8. Before any video, state the resolution, the clip length, and the clip count per video in the prompt. Start at 720p.
9. Package everything into one PDF and read it end to end as if a client sent it to you.

Do that once and you have a complete campaign for one product. The reusable part is not the images. It is the brief, the research, and the design definition, which is why steps three through five are the ones worth doing carefully even though they produce nothing you can look at.

Where this goes after the first campaign

Once the connector is live and the design definition exists, the same session extends well past product photography. Weekly reels. A content calendar built from the launch sequence the design pass already suggested. Paid media splits and the targets to track against them.

That is the actual shift worth naming. The generator connected to Claude Code is not a faster image tool. It is the point where the creative brief and the creative execution stop being two separate jobs handed between two separate people. The brief writes the prompt, the prompt makes the asset, the asset gets checked against the brief, and it all happens in one place with one shared memory of what the brand is.

Every step above is runnable by hand today, and running it by hand is how you learn which parts actually matter, which is why the whole chain is written out here rather than held back.

Read this online at claudecodeclub.ai