For developers & vibe coders

Ship video from your terminal.

Your agent writes the ad. You post the MP4.

Connect the Hubfluencer MCP to your coding agent and turn a single prompt into a finished, post-ready ad — or bring your own footage, product shots and logo for the agent to edit in. You keep the credits and access tokens in the app; the agent just makes the video, usually in a few minutes.

Get an access token See the REST API

Tokens live in the web app under Settings → Access tokens. Prepaid credits at $0.99 each — less in bulk — and drafts are free. The agent quotes the price and asks before it spends.

agent session

# You type
> Use Hubfluencer to make a 15s ad for my candle brand.

# Your agent calls
make_video({ prompt: "...", save_path: "./candle-ad.mp4" })

# You get back
→ { slug: "...", ready: true,
    video_url: "https://...mp4 (presigned, ~24h)",
    saved_to: "./candle-ad.mp4" }

A real render — one prompt, no editor opened. Yours arrives as a clean MP4, ready to post.

How it works

Three steps. One prompt. One MP4.

Connect your account

Create your account at app.hubfluencer.com and generate an access token (Settings → Access tokens, Generate videos scope) — or skip the copy-paste and run npx -y @hubfluencer/mcp login.

Drafts and planning are free — buy credits ($0.99 each, less in bulk) when you're ready to render.

Add the MCP

Register the Hubfluencer MCP server with your agent — one command or a small config snippet. Pick your tool in the Quickstart below.

npx -y @hubfluencer/mcp

That npx line is the whole server — your agent launches it on demand. Nothing to install, host, or update.

Prompt your agent

Say “Use Hubfluencer to make a 15s ad for my candle brand” and get an MP4 back.

Drafts are free. A short renders for 15 credits (≈ $15 max), a 5-scene editor ad for ~28 (≈ $28 max) — your agent confirms the price with you first, and most renders finish in a few minutes.

Quickstart

Wire it up to your agent.

Pick your tool. Each kit registers the same @hubfluencer/mcp server and ships a ready-made skill. The MCP gives your agent the tools; the skill teaches it the workflow — what things cost, how to poll, when to stop.

Add the MCP — one command

terminal

claude mcp add --transport stdio --env HUBFLUENCER_API_TOKEN=YOUR_TOKEN hubfluencer -- npx -y @hubfluencer/mcp

Paste it into your shell — not into a running Claude session, where it's read as a prompt instead of executed. All flags go before the server name; -- separates it from the command Claude Code runs. Use --scope project to write the server into .mcp.json at the repo root.

…or a config file

.mcp.json

{
  "mcpServers": {
    "hubfluencer": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@hubfluencer/mcp"],
      "env": {
        "HUBFLUENCER_API_TOKEN": "${HUBFLUENCER_API_TOKEN}"
      }
    }
  }
}

Teach the agent

Drop the skill at .claude/skills/hubfluencer-create/SKILL.md (project, committed) or ~/.claude/skills/… (personal). The directory name becomes the /hubfluencer-create command.

Download the kit

SKILL.md API.md README.md

Connect first: create a Generate-videos-scope token in the app and export it as HUBFLUENCER_API_TOKEN, or run npx -y @hubfluencer/mcp login. Never paste a token into a committed file — use ${HUBFLUENCER_API_TOKEN} expansion.

Add the MCP — one command

terminal

codex mcp add hubfluencer --env HUBFLUENCER_API_TOKEN=YOUR_TOKEN -- npx -y @hubfluencer/mcp

…or a config file

~/.codex/config.toml

[mcp_servers.hubfluencer]
command = "npx"
args = ["-y", "@hubfluencer/mcp"]

[mcp_servers.hubfluencer.env]
HUBFLUENCER_API_TOKEN = "YOUR_TOKEN"
# Optional:
# HUBFLUENCER_BASE_URL = "https://hubfluencer.com"
# HUBFLUENCER_OUTPUT_DIR = "/absolute/path/where/mp4s/may/be/written"

Restart Codex after editing config.toml. Manage with codex mcp list / get / remove.

Teach the agent

Install the skill at ~/.codex/skills/hubfluencer-create/SKILL.md (personal) or .codex/skills/… (project). For always-on guidance, paste the AGENTS.md section into ~/.codex/AGENTS.md or the repo root.

Download the kit

SKILL.md AGENTS.md README.md

Connect first: create a Generate-videos-scope token in the app, or run npx -y @hubfluencer/mcp login. If you logged in, omit the env block entirely — the server reads the saved token automatically.

Add the MCP — config only

OpenCode has no mcp add command. Hand-edit the JSON config. Note: type is local (not stdio), and the key is environment (not env).

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "hubfluencer": {
      "type": "local",
      "command": ["npx", "-y", "@hubfluencer/mcp"],
      "enabled": true,
      "environment": {
        "HUBFLUENCER_API_TOKEN": "YOUR_ACCESS_TOKEN"
      }
    }
  }
}

Goes in opencode.json (project root) or ~/.config/opencode/opencode.json. Restart OpenCode after editing.

Teach the agent

OpenCode reads a plain-Markdown AGENTS.md at the project root (or ~/.config/opencode/AGENTS.md). Drop the Hubfluencer usage section in there.

Download the kit

AGENTS.md README.md

Connect first: paste a Generate-videos-scope token as HUBFLUENCER_API_TOKEN in the environment block, or run npx -y @hubfluencer/mcp login and drop the block entirely.

Add MCP support, then the server

Pi has no native MCP — install the pi-mcp-adapter extension, then drop an mcp.json config.

terminal

pi install npm:pi-mcp-adapter

~/.pi/agent/mcp.json

{
  "mcpServers": {
    "hubfluencer": {
      "command": "npx",
      "args": ["-y", "@hubfluencer/mcp"],
      "env": {
        "HUBFLUENCER_API_TOKEN": "${HUBFLUENCER_API_TOKEN}"
      }
    }
  }
}

Heads up: Pi MCP support comes from a community extension, not a first-party feature — the adapter's field names could drift between versions, so verify against the pi-mcp-adapter README. A fully-native alternative is to ship a Pi Skill that drives the REST API with bash + curl.

Teach the agent

Copy SKILL.md to ~/.pi/agent/skills/hubfluencer-create/SKILL.md (global) or .pi/skills/hubfluencer-create/SKILL.md (project). Add AGENTS.md to the project root as the always-on pointer.

Download the kit

SKILL.md AGENTS.md mcp.json README.md

One config shape, many clients

Cursor, Windsurf, Claude Desktop and most other MCP clients accept the same mcpServers block:

mcp servers config

{
  "mcpServers": {
    "hubfluencer": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@hubfluencer/mcp"],
      "env": {
        "HUBFLUENCER_API_TOKEN": "${HUBFLUENCER_API_TOKEN}"
      }
    }
  }
}

Cursor — .cursor/mcp.json in the project, or ~/.cursor/mcp.json globally.
Windsurf — ~/.codeium/windsurf/mcp_config.json
Claude Desktop — claude_desktop_config.json via Settings → Developer → Edit config.

Field names occasionally differ between clients (env vs environment) — check your tool's MCP docs if the server doesn't appear.

Teach the agent

Grab the plain-Markdown guidance and drop it wherever your tool reads instructions — a rules file, project notes, or the system prompt. API.md is the same reference the skills consult.

Download the kit

AGENTS.md API.md

Connect first: create a Generate-videos-scope token in the app and reference it as ${HUBFLUENCER_API_TOKEN}, or run npx -y @hubfluencer/mcp login and drop the env block entirely.

Tool reference

What the agent can call.

Tool	What it does	Credits
`make_video`	One-shot: prompt in, finished MP4 out. Creates, generates, polls and downloads.	15+
`create_short`	Create a short draft from a prompt.	0
`generate_short`	Render a short draft.	15
`create_editor_ad`	Create a multi-scene editor ad draft for story prompts.	0
`upload_video`	Upload your own video clip and drop it onto the timeline as a scene.	0
`set_product`	Attach your product photo so it features across the AI scenes.	0
`set_logo`	Overlay your brand logo on the finished video.	0
`set_closing_image`	Set a custom end-card image — upload one or reuse the product shot.	0
`get_status`	Check a project's current stage / status.	0
`wait_for_completion`	Poll until the render finishes; call it again if it times out mid-wait.	0
`download_result`	Download the finished MP4 from its presigned (~24h) URL.	0
`list_renders`	List every render version with its status and download URL.	0
`retry_render`	Re-run a failed render from its saved snapshot.	0
`list_voices`	List available voice-over voices.	0
`get_credits`	Read the current credit balance before spending.	0
`list_projects`	List the account's recent video projects.	0

make_video is the one-shot path. A short render is 15 credits; a 5-scene editor ad is ~28 (a credit is $0.99, less in bulk) — preflight the exact figure with GET /api/editor/:slug/autopilot/cost, or pass dry_run to price a job for free.

Bringing your own media is free: upload_video drops your footage onto the timeline, and set_product / set_logo / set_closing_image add your brand. Beyond this curated set, the MCP also exposes the full granular editor — scenario, per-scene prompts, narration, voice and music — so the agent can direct an ad end to end. See the @hubfluencer/mcp tool list for everything.

Beyond one video

Your agent runs the whole content operation.

Feed it a product page and it can plan a campaign, draft a batch of ads, collect a client's approval, and stage the posting calendar — the same MCP covers every step.

Plan

extract_product_page turns a URL into facts and imagery; plan_campaign and generate_hook_variations turn the facts into hooks, angles and scripts — each with a credit estimate.

Draft

Materialize the hooks you like into editable drafts — multi-scene ads, shorts, or image carousels — grouped in campaign packs, with series for recurring shows.

Review

create_review_link mints an expiring, no-login URL where a client can approve or request changes — before you spend credits on the next batch.

Schedule

schedule_post stages a reminder calendar; you post, the agent marks it done. Auto-publish to TikTok/Instagram stays human-gated in the app.

Planning and drafting are free (20 AI assists a day); only rendering spends credits. The MCP wraps the same surface as the REST reference — carousels, tracking overlays, brand profiles and performance notes included.

Auth & credits

Prepaid credits, scoped tokens.

You buy credits and create access tokens in the app — $0.99 a credit, less in bulk. Nothing crypto here — just a balance and a bearer token. The agent quotes the cost and asks before it spends; you stay in control.

Access tokens

Created in the app under Settings → Access tokens. The agent scope is labelled “Generate videos” = video:generate + video:read. Agent tokens never get account:admin.

Environment variables the server reads:

HUBFLUENCER_API_TOKEN — required (unless logged in)
HUBFLUENCER_BASE_URL — optional, default https://hubfluencer.com
HUBFLUENCER_OUTPUT_DIR — optional, confines where MP4s may be written

Connect with no copy-paste

Run npx -y @hubfluencer/mcp login. It prints a URL and a short code; you approve the connection in the signed-in app. A scoped token is saved to ~/.hubfluencer/credentials.json and the server picks it up automatically — so you can omit HUBFLUENCER_API_TOKEN entirely.

terminal

npx -y @hubfluencer/mcp login

The agent never invents a token and never echoes one in its output.

Failure handling

402 — credits_insufficient: report required vs available, then stop (no loop).
409 — already running: keep polling, do not restart.
403 — insufficient_scope: the token lacks video:generate.
Retries: send an Idempotency-Key on generate calls so a retry can't double-charge.

Credits

Draft & plan — free (plus 20 AI assists/day)
Render a short — 15 credits (≈ $15 max)
5-scene editor ad — ~28 credits (≈ $28 max; preflight the exact cost)

A credit is $0.99, less in bulk — prepaid in the app. The skills have the agent quote the cost and get your go-ahead before spending.

Out of scope

Publishing to TikTok / Instagram needs a human-linked social account. The agent never auto-publishes — it returns the finished MP4 plus a ready-to-paste caption so you post it yourself.

Direct REST — no MCP

Prefer raw HTTP? Go for it.

Base URL is https://hubfluencer.com, everything lives under /api, and you authenticate with Authorization: Bearer <token>. Three requests take a short from prompt to MP4: create the draft, start the render, then poll until the stage is video_ready.

Read the API reference.

Every external endpoint, with parameters and example responses — no token needed to read it. The raw OpenAPI spec is linked from there too.

shorts.sh

# 1. Create the draft (0 credits) — response includes the slug
curl -X POST https://hubfluencer.com/api/shorts \
  -H "Authorization: Bearer $HUBFLUENCER_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"product_prompt": "15s ad for my candle brand"}'

# 2. Start the render (15 credits) — the Idempotency-Key makes retries safe
curl -X POST https://hubfluencer.com/api/shorts/SLUG/generate \
  -H "Authorization: Bearer $HUBFLUENCER_API_TOKEN" \
  -H "Idempotency-Key: gen-short:SLUG"

# 3. Poll until stage == "video_ready", then read latest_render.video_url
curl https://hubfluencer.com/api/shorts/SLUG \
  -H "Authorization: Bearer $HUBFLUENCER_API_TOKEN"

FAQ

Questions, answered.

How long does a render take?

A few minutes for most shorts; multi-scene autopilot runs can take longer. Poll roughly every 15 seconds — the skills already do.

What does a video cost in real money?

A credit is $0.99 — less when bought in bulk (packs and subscriptions). A short is 15 credits (up to ~$15), a 5-scene editor ad ~28 (up to ~$28) — drafts, planning and 20 AI assists a day are free, and the skills have your agent confirm the price with you before rendering.

Watermarks or usage restrictions?

No watermarks — the MP4 you download is the final asset, ready to post. You keep the rights to everything you upload.

Can I run it headless — CI, cron, a bot?

Yes. Auth is a plain env-var Bearer token, every feature is REST underneath, and the MCP server is a stateless npx process — anything that speaks MCP or HTTP works.

Where do I get help?

The Discord is the fastest lane — or email contact@hubfluencer.com. Bug reports and feature requests about the MCP kits are especially welcome.