Best for
- Heavy users who need scripted, batched, or pipeline-ready Flow generation
- Automation and AI-video projects that want to expose Flow generation to agents
- Developers with Google Flow access and Veo credits outside restricted regions
G
gflow-cli MCP Server
Community
Drive Google Flow's Veo video and Imagen image generation from the CLI or an AI agent.
- Category
- Other #204 of 230
- Stars
- ★ 354 Very popular
- Transport
- stdio (local process)
- Runtime
- Python · Prebuilt binary
- Credentials
- API key / credential required
- License
- MIT
- Last commit
36FMRS · D
gflow-cli gives users who already have Google Flow access a scripted, batched, agent-ready entry point to Flow generation, and ships an MCP server so coding agents can drive it. It is explicitly alpha, reverse-engineered, and unaffiliated with Google, relies on a headed Chromium with a real account session, and spends the user's own credits on video generation. It suits advanced users who accept these limits and risks, and is not intended for those wanting official support or purely headless server-side deployment.
Strongest · Documentation 10/20 Weakest · Setup experience 5/20
Why each score
- Reliability 6/20
- Static review only; evidence is limited to the supplied README and server.json. Positives: the README openly labels the project alpha, keeps a KNOWN_ISSUES list, defines distinct exit codes for failure classes (e.g. selector drift = exit 23), claims per-release LIVE_VERIFICATION evidence, and the manifest version (0.78.0) matches the README with a coherent entry point (`gflow mcp run` / `gflow serve`). However, the verifiable portion is thin: every 'production-stable / verified end-to-end' claim is self-asserted in README (untrusted evidence), no committed test files covering the server's key paths are provided, no CI workflow file contents are shown, and there is no tool list beyond the manifest to confirm declared tools match real behavior. The product fundamentally drives a headed Playwright Chromium against a private Google API via UI automation, self-declared to drift when Google changes UI, with the HTTP transport blocked (401 + reCAPTCHA). Per static calibration the ceiling is 12; deducting for absent test evidence and fragile external dependencies gives 6.
- Security and permissions 8/20
- No red-line evidence found: no credential theft, no covert exfiltration, no real tokens or secrets embedded in install examples, no fabricated maintainer identity. Transparency is a genuine strength: it states it runs on the user's own Google account and credit allowance, explicitly claims no proxies and no fingerprint spoofing, distinguishes free image ops from credit-spending video, ships the Claude Code plugin disabled by default (because enabling auto-starts MCP servers), and offers a hard guarantee via `gflow mcp run --no-spend` that never registers spending tools. Deductions: the server's whole purpose is to let automation drive a persistent Chrome profile holding the user's Google session; the manifest exposes only one non-secret env var (GFLOW_CLI_HOME) and declares no confirmation or permission boundary at the machine-readable level; data-flow disclosure (Google private API, optional routing to S3/MinIO/GCS) lives in README prose rather than in a reviewable contract; and deliberate pacing to look 'unremarkable' carries Google ToS account risk, though it is honestly disclosed. Score 8: no red line, but permissions/confirmation/scoping are not fully codified.
- Maintenance 7/20
- Evidence: MIT license is explicit, version 0.78.0 indicates rapid iteration, the PyPI publish path plus `gflow update` exists, and badges reference CI, release, SonarCloud and OpenSSF Scorecard with a claim of real-Flow verification per release. Visible governance gaps remain: 55 open issues against 203 stars is high, the docs state single-maintainer ownership (bus factor 1), no security-disclosure policy or response channel is shown, there is no machine-readable dependency-lock guarantee (the README itself warns local-checkout installs ignore uv.lock and may pull an untested Playwright build), and the version is still 0.x/alpha with no long-horizon track record available statically. Anchored at 10 (active but governance/versioning gaps), rounded down to 7.
- Documentation 10/20
- Documentation is the strongest dimension and is layered and reviewable in structure: a 60-second quick start (install, `playwright install chromium`, `gflow auth login`, `credits user`, generation examples) plus links to USER_GUIDE/USAGE/CONFIGURATION/EXTERNAL_STORAGE/MCP/ARCHITECTURE/SECURITY/KNOWN_ISSUES/CHANGELOG; concrete cost and failure disclosure (only video bills, exit-code semantics, batch items recorded before submission); unusually candid limitation disclosure (headed-browser dependency, pure-HTTP transport blocked by 401 + reCAPTCHA, two frontends mid-migration to flow.google.com, the local-checkout Playwright trap); and a stated CI-enforced CLI-to-MCP parity contract. Deductions: all of the above is self-asserted README content that cannot be statically verified against the actual MCP tool list and parameters; the client-configuration examples live in the referenced docs/MCP.md, which was not supplied, so the key 'tool parameters and client wiring' evidence is missing; and exact credit consumption per generation and rate limits are not given as numbers. Held at 10 (usable but with hidden assumptions and troubleshooting gaps).
- Setup experience 5/20
- The install path is nominally clear: one PyPI package (gflow-cli), runtimeHint uvx, stdio transport, packageArguments `mcp` + `run`, with `gflow serve` for Streamable HTTP; the README provides a one-line `uv tool install gflow-cli` plus uvx usage and notes platform coverage including Windows. But statically this is not a few-step, robust path: it requires a separate `playwright install chromium` (~150 MB), a mandatory interactive `gflow auth login --browser chrome` against a real Chrome session to clear login and reCAPTCHA (cannot run headless, and the project's own docs say the container image can introspect but cannot generate), a 30-90s warm-up on first call, and a manual Playwright version pin when installing from a local checkout. In other words, reaching a working connection in a mainstream client still depends on manual browser interaction and many external preconditions, and no client config example is provided in the supplied material. Capped at 15 for static review and significantly reduced to 5.
Static review · not runListed 2026-09-18
Read the FMRS scoring method →Fit and risk
What it can accessWrites / deletes local filesUses the networkChanges third-party account dataControls a browser
Not for
- Users expecting official Google support or an official API
- Users unwilling to accept account-automation risk or spend their own Flow credits
- Users needing headless pure-HTTP or serverless browserless deployment
- Users wanting to redistribute or resell the tool beyond Google's services
Required permissions
- Requires the user's own logged-in Google Flow session and account credentials
- Persists a local Playwright Chromium profile (default per-user directory, configurable via GFLOW_CLI_HOME)
- Writes generated outputs to a local output directory (or via GFLOW_CLI_STORAGE_URI to S3, MinIO, or Google Cloud Storage)
- Reaches Google's private Flow interfaces (aisandbox-pa.googleapis.com or the migrated batchexecute endpoint)
- Video generation spends Flow credits on that account
Risks and side effects
- The tool is alpha and reverse-engineered with no Google affiliation, and can break when Google's endpoints or UI change without notice
- Automation is subject to Google's ToS and carries account-flagging risk; the project deliberately uses no proxies, no fingerprint spoofing, and does not pretend it isn't automation
- Video generation spends real credits; when the UI drifts the CLI fails fast and loudly (e.g. selector drift = exit 23) rather than resubmitting
- The MIT license covers only its code and grants no rights to Flow, Veo output, or any Google service
- Installing from a local checkout without pinning Playwright can pull an untested browser driver that silently wedges generation
Setup
Before you start
Runtime：Python · Prebuilt binary
Other optional settings (4)
GFLOW_CLI_HOME
Directory where gflow keeps its Chrome profile, config and database; defaults to a per-user directory, optional.
GFLOW_CLI_OUTPUT_DIR
Where generated output files are written; optional, outputs can instead be routed via GFLOW_CLI_STORAGE_URI.
GFLOW_CLI_STORAGE_URI
Storage URI to route outputs to S3, MinIO, or Google Cloud Storage; see docs/EXTERNAL_STORAGE.md.
GFLOW_CLI_FLOW_HOST
Selects the Flow frontend host (labs.google vs flow.google.com) during the ongoing migration; optional.
- Have a Google account with Flow access
- Install with uv: uv tool install gflow-cli (or pip install gflow-cli)
- One-time browser install: uv tool run --from gflow-cli playwright install chromium (~150 MB)
- One-time login: gflow auth login --browser chrome (opens a real Chrome window)
- Check balance with gflow credits user
- Register the MCP server with uvx gflow-cli mcp run, adding --no-spend to never register credit-spending tools
- Optionally set GFLOW_CLI_HOME for the Chrome profile, config and database location, and GFLOW_CLI_OUTPUT_DIR for outputs.
.mcp.json
{"mcpServers":{"gflow-cli":{"command":"uvx","args":["gflow-cli","mcp","run"],"env":{"GFLOW_CLI_HOME":""}}}}
Shown for Claude Code. Other clients may use a different file or key (VS Code uses "servers") — the configurator below converts it.
.vscode/mcp.json
{
"servers": {
"gflow-cli": {
"command": "uvx",
"args": [
"gflow-cli",
"mcp",
"run"
],
"env": {
"GFLOW_CLI_HOME": ""
}
}
}
}
Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).
Terminal
claude mcp add gflow-cli -e GFLOW_CLI_HOME= -- uvx gflow-cli mcp run
Run it in a terminal; replace any <…> placeholders with your own values first.
Check that it works
After configuring the gflow-cli MCP server (or enabling the Claude Code plugin), the client's tool list should show gflow's image/video generation tools; run `gflow credits user` or try a free image-generation prompt to confirm the connection — video generation bills your Flow credits.
Troubleshooting
- Confirm you ran gflow auth login --browser chrome and prefer --browser chrome, which marks the profile as a real-Chrome profile
- The first call takes 30 to 90 seconds while Chromium warms up; later calls reuse the warm session, so don't judge failure from the first run
- Check balance with gflow credits user to confirm credits are available for video generation
- If installing from a local checkout, pin Playwright explicitly: uv tool install --force --with playwright==1.59.0 .
- If selector drift causes exit 23, consult KNOWN_ISSUES and docs; batch items are recorded before submission so a broken run does not silently burn credits
- For multi-account or output/storage routing issues, see docs/CONFIGURATION.md and docs/EXTERNAL_STORAGE.md
Things to try
Once connected, you can ask your AI assistant things like:
- Generate an image of a hot air balloon over Tokyo at sunrise using Google Flow
- Generate a 16:9 slow cinematic push-in video of a sunlit forest clearing
- Check my current Flow credit balance
- Create a reusable Character (face and body reference) for consistent subjects across generations
Use cases
Batch-generate Veo videos and Imagen images in automation pipelines
Let coding agents (e.g. Claude Code) call Flow generation through MCP
Mint reusable Characters with gflow character for consistent subjects across generations
Rewrite prompts before generation with prompt tooling such as --tool creative-director
Extend an existing clip past Flow's 8s ceiling with gflow video extend
Supported clients
Claude CodePartial support
Listed from the project's documentation, not tested by this site.
Overview
gflow-cli is a Python CLI and MCP server for Google Flow. Through its MCP server, coding agents such as Claude Code can drive Flow for programmatic control over Veo video generation (text-to-video, image-to-video, reference-to-video, extend, chain) and Imagen image generation (text-to-image, image-to-image, upload, upscale, batch). It is alpha, reverse-engineered, and not affiliated with Google; its MIT license covers only its own code and grants no rights to any Google service. It drives a headed Playwright Chromium against your own Google Flow session and bills against your own account, where only Veo video generation spends credits while images and composition operations are free.
Similar servers
Hevy MCP
77 · B
Manage your Hevy workout data from AI assistants via MCP.
Firecrawl MCP Server
75 · B
Firecrawl's official MCP server for web search, scraping, and structured extraction for AI agents
BioMCP
75 · B
One binary. One grammar. Evidence from the biomedical sources you already trust.
Compartment
75 · B
Encrypted, fully offline long-term memory for AI agents
Source revision 4ee2c60af9ca Data synced 2026-11-02 Read the FMRS scoring method