Flow Kit: Driving Google Flow Through a Signed-In Chrome Tab

The problem Flow Kit addresses: Flow has no public API

Google Flow is a browser product. There is no documented public endpoint that a script can call to submit a generation job, and no API key flow described in the repository. Flow Kit exists because the only place Flow's backend calls can be signed is inside a signed-in flow.google.com tab. The README states this directly: the extension 'mints reCAPTCHA and runs Flow's batchexecute RPCs inside a signed-in flow.google.com tab, which is the only place they can be signed.' That sentence is the whole design rationale. Everything else in the project is scaffolding around it. The audience is people producing narrative video at scene granularity: the README describes a 50-scene project and a 25-scene story arc, with per-character reference images carried across scenes. If you generate one clip occasionally, the setup cost of a browser bridge, a FastAPI service and ffmpeg will not pay for itself.

The Chrome extension is the bridge, and the pipeline is the product

The architecture has two halves. The first is a Chrome MV3 extension (the badge in the README lists Chrome MV3) that sits in a logged-in Flow tab and performs the RPC calls on the pipeline's behalf. The second is a Python 3.10+ service built on FastAPI 0.115, which orchestrates the work and shells out to ffmpeg for media assembly. The README describes the flow as: 'story to entities to reference images to scene images to 8s video clips to narration (TTS) to concat to thumbnails to YouTube upload.' The reference image stage is the part with the most concrete mechanism described. A character is generated once as a reference, then the system reuses that reference in every scene, which the README says maintains 'the same face, clothing, and features' across settings and lighting. The README shows this with a doctor character across four scenes and a defector character across ICU, hospital, interview and street settings, all from a single 50-scene project. Outputs listed include reference images, scene images, 8-second clips with camera motion and sound effects, an optional 4K upscale, voice-cloned narrator TTS, and a concatenated final video. The v1.1.0 release is titled 'Workflow schema support for Low Priority models', which indicates the workflow definition is a versioned schema and that model priority is a field within it.

What you need installed before the first render

The README's badge row is the honest dependency list: Python 3.10+, Chrome MV3, FastAPI 0.115, and ffmpeg marked as required. The Python version floor of 3.10 is stated, not implied. ffmpeg is not a Python package here; the pipeline calls it for concatenation and trimming, so it has to be on the host PATH at whatever version the code invokes. The Chrome extension is loaded into a browser profile that is already signed in to flow.google.com, because the RPC signing depends on that session. The README also points to CLAUDE.md as the documentation entry point, and to a DeepWiki page, which suggests the operational detail lives outside the README itself. One detail worth flagging: the badge links in the README point at a different repository path (tuannguyenhoangit-droid/google-flow-agent) than the repository under review, so the stars and issues badges do not describe this project. Treat them as noise. Because the material does not include a full install transcript, the exact commands for starting the FastAPI service, loading the extension, and invoking a project are not verifiable from what is supplied here; the README describes stages and dependencies rather than a copy-paste sequence.

The failure mode is the browser session, not the Python code

The design decision that makes Flow Kit work is the same one that makes it fragile. Because generation depends on a signed-in tab minting reCAPTCHA tokens and issuing batchexecute calls, the pipeline inherits every property of that session. If the tab is closed, logged out, or the session expires mid-render, the RPCs stop being signed and the run fails. There is no documented fallback path, no API key alternative mentioned, and no queue that survives a browser restart. This also means the system is coupled to Flow's internal RPC surface, which is not a public contract. The repository cannot pin that surface. A change on Flow's side can break generation without any commit in Flow Kit, and the version history here (v1.0.1, v1.0.2, v1.1.0 within roughly four months) is consistent with a project that has to keep pace with an external target. A second limitation is scope: this is not a general video tool. It generates through one provider, in 8-second clips, and concatenates them. If your output is a single long take, or you need frame-accurate editorial control, the clip-and-concat model is the wrong shape.

How it differs from calling a hosted video generation API

The obvious alternative is a provider that exposes a documented HTTP API with keys, quotas and a versioning policy, such as the video endpoints offered by the major model vendors. The difference is not quality of output; it is who owns the contract. With a hosted API, you send a request to a documented endpoint and the provider commits to keeping that endpoint working, with deprecation notices and rate limits you can read in advance. With Flow Kit, you are driving a consumer web product through its own internal calls from a logged-in browser, which means no quota documentation, no deprecation policy, and no support channel if a call starts returning an error. What you get in exchange is access to Flow's specific generation behaviour and the reference-image consistency mechanism the README documents, without waiting for an official API. That trade is real and it should be made deliberately. If your production schedule cannot absorb an unannounced breakage, the hosted API is the safer choice even if it costs more. If Flow's output is the thing you specifically need, Flow Kit is currently the route to it.

Maintenance cost and the MIT licence

Maintenance here is dominated by external change, not internal code. The pipeline's own logic (schema, stages, ffmpeg calls) is ordinary Python that a maintainer can read and patch. The part that will generate work is the RPC layer, because it tracks a product the maintainer does not control. The release cadence in the supplied material, three releases between April and May 2026 and a push in September 2026, suggests ongoing upkeep rather than a finished tool. Budget for the possibility that you are the one patching the extension when a call signature shifts. The project is MIT licensed, which permits commercial use, modification and redistribution provided the copyright notice and permission notice are preserved. MIT also means no warranty and no liability from the authors, which matters more than usual for a tool that automates a third-party service on your behalf. The material does not address Google's terms of service for automated access to Flow, and nothing here should be read as legal advice on that point. If you plan to use this commercially, the terms question is separate from the licence question and needs its own answer.

Who should run this, and what to check on day one

Flow Kit fits a specific operator: someone producing multi-scene narrative video who is willing to run a browser bridge and a local service, and who values Flow's generation plus the reference-image consistency described in the README over an official API contract. The 50-scene and 25-scene examples in the repository are the scale it was built for. It does not fit teams that need an SLA, teams that cannot keep a Chrome session alive during renders, or anyone who wants a single command that produces a finished video without touching a browser profile. On day one, confirm the extension loads under Chrome MV3 in your signed-in profile and that token minting succeeds, confirm ffmpeg is on PATH and callable by the service, and read CLAUDE.md rather than the README, since the README points there for documentation. Then run the smallest possible project, one character, one reference image, one scene, before committing to a long render. If the one-scene run completes and the character reference carries through, the rest of the pipeline is mostly assembly.

Editorial conclusion

Adopt Flow Kit if you already have a signed-in flow.google.com account and want scene-by-scene video generation driven from Python or an agent rather than a browser UI. Do not adopt it if you need an official, stable API contract, or if you cannot keep a Chrome tab open and authenticated for the duration of a render. Before committing, verify three things: that the Chrome MV3 extension loads and mints reCAPTCHA tokens in your own signed-in tab, that ffmpeg is present on the host at the version the pipeline expects, and that the Flow RPC surface the extension calls has not changed since the last commit, because nothing in the repository can insulate you from that.

Official sources

1. crisng95/flowkit on GitHub
2. Issues
3. License: MIT
4. README
5. Releases