Flowise Pricing: The License Boundary, Not the Plan

Flowise pricing carries no license fee for the open-source build, but a single production team still lands at roughly $550 to $1,800 a month once hosting, Postgres, Redis, a vector database and model tokens are priced. The plan is not the bill.

Our position is narrower than the usual "the sticker price hides things" observation, and it is checkable. Flowise ships two licenses in one repository. Everything outside packages/server/src/enterprise is Apache 2.0; everything inside it, including the sso and rbac directories, is governed by a separate FlowiseAI Commercial License that permits production use only with a paid subscription. So the first question in a Flowise pricing exercise is not "which plan". It is: where does the free part stop, and what do the parts on the other side of that line cost when you buy them somewhere else? We call that exercise the Boundary Bill, and this article runs it end to end.

The problem it solves shows up as confusion, not as sticker shock. On July 2, 2025, a Flowise user posting as DaniRod9 opened issue #4779 after wiring Langfuse and LangSmith into an agentic flow and finding that "all cost and token usage metrics remain at $0.00" while the traces themselves arrived fine. They were not asking what Flowise costs. They were asking a harder question: what is this thing spending right now, per flow? A team that cannot answer that cannot forecast the largest line on its own invoice.

The short answer: Flowise's Apache-licensed build has no license fee, but SSO, RBAC and workspaces sit outside that license, and compute, state, retrieval, tracing and tokens sit outside Flowise entirely, so budget the boundary, not the plan.

Last updated: July 30, 2026.

The Boundary Bill: three bands, three different people who have to approve them.

What Flowise Pricing Actually Covers

Flowise pricing spans four separate billable surfaces, and only one of them appears on a pricing page. There is the hosted cloud subscription. There is the Enterprise license that unlocks the commercially licensed code. There is the infrastructure you rent if you self-host. And there is model spend, which is billed by whichever provider your flows call and is usually the largest line of the four. Treating the first as "the price of Flowise" is how teams end up presenting a two-figure monthly number to a finance partner and returning three months later with something four figures wide. Total cost of ownership for this tool is decided almost entirely by the other three surfaces.

One caveat has to come first, because it changes how you should read every number below. We attempted to fetch Flowise's public pricing page on July 30, 2026 through three separate methods: a plain HTTP client, a browser-user-agent request, and a real browser session. All three received an HTTP 307 redirect from https://flowiseai.com/pricing to /auth/login, and the rendered page was a sign-in form. The Internet Archive was also unreachable from our environment. So the tier figures widely quoted in secondary write-ups, a free tier and two paid monthly plans in the mid-double digits, are ones we could not verify against the vendor's own page, and we do not reproduce them here as fact. That is not a small footnote. If a public pricing page has moved behind a sign-in, a procurement team cannot budget from it either; they have to ask, and they should ask in writing.

What we could verify came from primary sources that are still open: the Flowise repository and its two license files, the official documentation, and the pricing pages of the components a self-hosted deployment actually needs. Every dollar figure in this article was fetched from a named vendor's own pricing page on July 30, 2026, and is linked at the point of use.

Two of the six surfaces are opaque. Four are not. The useful move is to price the four you can and treat the two you cannot as a negotiation, which is exactly what the rest of this piece does.

The License Boundary: Where Free Flowise Stops

The single most load-bearing fact in Flowise pricing is not a number. It is a directory path. The repository's root LICENSE.md states that all content residing under packages/server/src/enterprise, plus files carrying an explicit copyright notice such as IdentityManager.ts, is licensed under a separate Commercial License, and that content outside those areas is available under Apache 2.0. That is the line. Everything on one side is free to run in production; everything on the other side is not.

We listed the contents of that directory through the GitHub API on July 30, 2026. It contains subdirectories named sso, rbac, controllers, database, middleware, routes, services and emails. Read that list as a procurement document rather than a codebase and the shape becomes obvious: single sign-on and role-based access control, the two controls an enterprise security review asks about first, live on the paid side of the line, in the same repository that is described everywhere as open source.

The documentation says the same thing in plainer words. The SSO configuration page states that "SSO is only available for Enterprise plan," and covers Microsoft Entra ID, Google and Auth0 as the supported providers. The workspaces page states that "Workspaces are only available for Cloud and Enterprise plans." So multi-team separation is also outside the free build.

What the Apache-licensed build gives you instead, for authentication, is documented on the app-level authorization page: a single FLOWISE_USERNAME and FLOWISE_PASSWORD environment pair, an approach the docs themselves mark as deprecated as of v3.0.1 in favour of a JWT-based flow, with a warning that leaving the default JWT secrets in place "could increase the chances of attackers to forge valid tokens and impersonate users." One shared credential, guarding a canvas that holds every model key and connector credential your flows use, is not a control an auditor will accept for a system that can send email and write to a CRM.

The licensing ambiguity has been raised repeatedly by the community rather than only by critics. In issue #5164, filed on September 3, 2025, a contributor asked the maintainers to add explicit wording to the LICENSE file, citing "concerns about whether packaging Flowise for commercial use is legally safe" and worries that enterprise code sitting in the same repository might affect Apache 2.0 distribution. An earlier issue #1460, from December 2023, raised the compatibility of appended commercial terms with Apache 2.0 at length. Neither is a scandal. Open-core is a legitimate model and Flowise is unusually transparent about where its line sits. But a buyer who reads "open source, 55,046 GitHub stars" and stops there has not read the part that decides their security review.

This is where a Flowise pricing conversation should start, and almost none of them do. Our earlier analysis of no-code agent builders and what IT will approve found the same structural pattern across the category: teams evaluate a tool on the tier that lacks the controls they will be required to have, then discover the gap at the exact moment the pilot is supposed to become production. Flowise is a clear, well-documented instance of it rather than an exception to it.

The Boundary Bill: A Method You Can Run in One Sitting

The Boundary Bill is five steps, it takes about an hour, and it works on any open-core tool, not just this one. We use it here on Flowise pricing because Flowise publishes enough primary material to run it honestly.

Step 1 — Draw the license line. Open the repository's LICENSE file and find the sentence that says which paths are not Apache-licensed. Then list the contents of those paths. Do not read the marketing page for this; read the file. For Flowise the answer is packages/server/src/enterprise, and the interesting contents are sso and rbac.

Step 2 — Read the vendor's own production guidance as a bill of materials. The running in production page is unusually specific: it recommends "2 main servers with load balancing, each starting from 4vCPU 8GB RAM" and "4 workers, each starting from 4vCPU 8GB RAM." It also notes that SQLite is the default but that "when running at scale, its recommended to use PostgresQL," and points at AWS S3 for storage and AWS Secret Manager for the encryption key. That is six compute instances, a managed database, an object store and a secret manager, specified by the vendor, before you price anything.

Step 3 — Add the components the tool depends on but does not include. Queue mode, the mechanism that lets workers scale independently of the main server, requires Redis as the broker. Retrieval requires a vector store. Cost visibility requires a tracing backend. None of these ship with Flowise.

Step 4 — Price each line from the vendor's own page, with a date. Not "roughly a few hundred dollars." An instance type, a plan name, a figure, a date. Undated ranges are the single most common defect in tool-cost articles and they are useless six weeks later.

Step 5 — State the unpriceable lines rather than omitting them. Engineering time to stand it up. Security review. Upgrade labour across a repository that had 1,034 open issues on the day we checked. The Enterprise quote itself. A bill that pretends these are zero is a worse artifact than one that lists them at "unknown."

The rest of this article is steps 2 through 5, executed.

Line One: Compute, Priced Against Flowise's Own Production Doc

Compute is the first line where Flowise pricing stops being abstract, and it is larger than most teams expect because the vendor's own floor is high. Flowise's production documentation specifies six instances at 4vCPU and 8GB each. On Render, verified July 30, 2026, the smallest web-service instance meeting an 8GB specification is Pro Plus at $175 a month for 8GB and 4 CPU. Six of those is $1,050 a month in compute alone, before a database, before retrieval, before a single token.

Render is one reference platform, chosen because it publishes complete per-instance figures on an open page. A team on AWS or a plain VPS will land somewhere different; the point of the table is the shape, which is that the gap between "a container running Flowise" and "the deployment its own documentation describes" is a factor of seven on this line.

Most teams do not start at six instances, and they should not. A reasonable single-team production shape is one main server and one worker, which is $350 a month at Pro Plus, or $170 if you accept 4GB instances and knowingly sit under the documented floor. That trade is legitimate as long as it is written down as a decision rather than discovered during an incident. What is not legitimate is presenting the $25 Standard instance you prototyped on as the production number.

One more compute-adjacent cost hides in the hosting platform's own tiering, and it rhymes with the Flowise license boundary in a way that is worth noticing. Render's SAML SSO, SCIM, advanced RBAC roles and organization audit logs sit on its Scale workspace plan at $499 a month; the Pro workspace plan is $25. The governance controls are on the upper tier at the hosting layer too. When a buyer complains that enterprise features are always upsold, they are describing an industry norm, not a Flowise quirk. That is precisely why the boundary has to be drawn deliberately rather than assumed.

Line Two: State, and the Default That Does Not Survive Production

Flowise stores chatflows, credentials, chat history, document-store metadata and API keys, and by default it stores them in SQLite on the container's local disk. The documentation is direct that this does not scale, recommending PostgreSQL for production. That single sentence converts a free default into a recurring line item, and it is a line item that grows with conversation history rather than with the number of flows.

Managed Postgres on Render, verified July 30, 2026, runs from $6 a month for a 256MB Basic instance to $100 for Pro-8gb with 8GB RAM, 2 CPU and 200 connections, with expandable storage at $0.30 per GB. Connection limits matter more here than they look: queue mode means multiple worker processes each holding pooled connections to the same database, so the 100-connection ceiling on the Basic tiers is a real constraint rather than a paper one.

Then Redis. Queue mode is what the production documentation is describing when it separates main servers from workers: the main server accepts a request, writes a job to Redis, and a worker picks it up and executes the flow. Without Redis there are no workers, and without workers a long-running agentic flow blocks the process that accepted it. Render's Key Value plans run $10 a month for 256MB Starter, $32 for 1GB Standard, and $135 for 5GB Pro. Call it $10 to $32 for most teams.

The third state line is object storage. Flowise's production guidance points at S3 for file storage, and the file-upload and document-store features write there. Volumes are usually modest for text corpora, but this is the line that surprises teams doing image or audio work, because it scales with what users upload rather than with what you built.

Line Three: Retrieval, the Line Nobody Budgets

Almost every Flowise deployment worth paying for does retrieval, and retrieval needs somewhere to put vectors. The in-memory vector store that makes demos easy is not a production answer, because it dies with the process and re-embedding a corpus on every restart converts a storage cost into a token cost.

Pinecone's pricing, verified July 30, 2026, has a free Starter tier with up to 2GB of storage, 2 million write units and 1 million read units per month; a Builder plan at $20 a month flat; a Standard plan with a $50 monthly minimum; and Enterprise at a $500 monthly minimum. Beyond the minimum, Standard bills storage at $0.33 per GB per month, write units at $4 to $4.50 per million and read units at $16 to $18 per million depending on cloud and region, with egress at $0.10 per GB after 100GB included.

Read units are the line that behaves unlike the rest of the bill. Every retrieval-augmented prediction issues at least one query, and a flow that fans out across a router and then queries per branch issues several. A team that models retrieval at one query per user message will underestimate a multi-agent flow by whatever its fan-out factor is. That is not a Pinecone criticism. The unit pricing is published and clear. It is a warning about modelling, and it is the same modelling error that makes agentic flows blow through prediction quotas on hosted plans.

The free Starter tier is genuinely usable for a prototype and for small internal corpora. The jump to a $50 minimum arrives with production traffic rather than with data volume, which means it usually lands in the same month the pilot is declared successful.

Line Four: Tokens, the Only Line That Moves 36x

Model spend is where Flowise pricing stops being about Flowise. Flowise does not resell tokens; your flows call a provider with your key, and the provider bills you. This is the largest line in most deployments and the only one that changes by more than an order of magnitude based on a decision made inside the canvas: the model chosen in a node's dropdown.

Take a modelled retrieval prediction of 3,000 input tokens and 400 output tokens. Those figures are our assumption for illustration, not a measurement, and you should replace them with your own trace data before you use this table for a budget. Applied against published rates verified July 30, 2026 from Anthropic's pricing documentation and OpenAI's API pricing page:

Same flow, same volume, same prompt: $6.90 or $250 at 10,000 predictions depending only on which model the node points at. That is a 36x spread on the largest line of the bill, controlled by a dropdown that any builder with canvas access can change.

Two dating notes, because both matter to a budget. Anthropic's documentation states that Claude Sonnet 5's $2 and $10 rates are introductory pricing in effect through August 31, 2026, after which standard pricing of $3 and $15 applies, a 50% increase on that row, arriving on a known date. The same page also notes that Claude 4.7 and later models use a newer tokenizer producing approximately 30% more tokens for the same text, which raises effective cost independently of the headline rate. A budget built on last quarter's rate card and last quarter's tokenizer will be wrong in the same direction twice.

Batch processing halves both input and output rates on Anthropic's models, and prompt caching charges cache reads at 0.1x the base input price. For a Flowise flow with a large fixed system prompt and a retrieved-context block, caching is the biggest cost lever available, and it costs nothing to try. We covered the mechanics of choosing per task rather than per platform in our earlier piece on how AI model routing cuts LLM costs.

Line Five: Evidence, and Why the Cost Field Reads $0.00

This is the line that turns the problem card into a budget item. Flowise documents integrations with several tracing backends, among them Langfuse, Arize, Opik, Phoenix, Lunary and LangWatch, and none of them ship with it. Tracing is a separate subscription, and it is the only way to answer "what did this flow cost last month" with evidence rather than an estimate.

Langfuse's pricing, verified July 30, 2026, offers a free Hobby tier with 50,000 units a month, 30-day retention and 2 users; Core at $29 a month with 100,000 units, 90-day retention and unlimited users; Pro at $199 with three-year retention; and Enterprise at $2,499. Overage runs $8 per 100,000 units, falling to $7 above a million and $6.50 above ten million. Retention is the variable that quietly decides the tier: 30 days is enough to debug, and nowhere near enough to answer a compliance question about what an agent did last quarter.

Now the defect from the problem card. Issue #4779, filed July 2, 2025, reports that in agentic flows with streaming disabled, traces reach Langfuse and LangSmith correctly but every generation step shows $0.00 and zero tokens. The filer went further than most bug reports do: they inspected the node output inside Flowise and found the usageMetadata object present and populated with correct token counts, which localises the failure to the handoff between Flowise and the tracing handler rather than to the model provider. A month later, issue #5015 reported a related pattern in which OpenAI models showed usage and cost in Langfuse while Gemini, Mistral and Claude nodes showed latency only. Both issues are now closed.

The procurement lesson survives the fixes, and it is the one worth carrying into any tool evaluation. Cost attribution in a visual builder is a pass-through of provider metadata through a plug-in handler, and pass-throughs break silently per provider and per node type. A $0.00 reading is indistinguishable from a genuinely free step, which means the failure mode of your cost telemetry is under-reporting, not an alert. Before you trust any per-flow cost number, run one deliberately expensive prediction through each provider you use and confirm the figure appears in the trace. If it does not, your budget line is decorative. Our earlier analysis of AI observability and audit trails sets out why the record has to be produced by the layer that authorises the call rather than reported by the tool that made it.

Line Six: Identity, Which Is Not in the Free Build

If your security review requires SSO in front of the builder, the Apache-licensed Flowise build does not have it, and no amount of infrastructure spend fixes that. You have exactly three options and all three carry a price.

Option A — buy Flowise Enterprise. This unlocks the commercially licensed sso and rbac code and, per the documentation, is the tier on which SSO is available at all. Price: quote-only. It is the correct option if you also want workspaces, organization-level roles and vendor support, and it is the only option that puts identity inside the product rather than in front of it.

Option B — put an identity proxy in front of the container. You keep the Apache build and terminate SSO at the edge with an identity-aware proxy or an SSO vendor. Real reference price: WorkOS, verified July 30, 2026, charges $125 per SSO connection per month for the first 15 connections, dropping to $100 each for 16 to 30, with Directory Sync priced identically and audit-log streaming at $125 per SIEM connection per month plus $99 per million events retained. One enterprise customer connection is therefore $1,500 a year, which is not trivial but is knowable, unlike a quote.

Option C — accept the shared credential. FLOWISE_USERNAME and FLOWISE_PASSWORD, one pair, shared. Free, deprecated since v3.0.1, and unacceptable in any environment where the canvas holds production credentials. It is a legitimate choice for an isolated internal sandbox with no live connectors and nothing else.

There is a fourth cost here that no pricing page carries, and it is the one we think is most often mispriced: what the flow itself authenticates as. A Flowise flow that calls Gmail, a CRM or an internal API does so with credentials someone pasted into a node. Those credentials belong to a person, they carry that person's access, and they keep working after that person leaves. Rate limiting does not help. Flowise's rate limit feature is documented as operating per chatflow and tracked by IP address, aimed at public chatflows with no API authorization, which is a spam control rather than an authorization control. We wrote about the underlying discipline in non-human identity: owner, scope, expiry, and the short version is that an agent credential with no owner and no expiry is an unbudgeted liability rather than a saved line item.

The Number in Every Unit: Monthly, Annual, Per Prediction

Here is the assembled Boundary Bill in three shapes. Every infrastructure figure is a plan or instance price fetched from the named vendor on July 30, 2026. The Flowise license line is $0 because the Apache build carries no fee; it is not $0 because Flowise is free.

That subtotal is the part of total cost of ownership you can lock in advance. Now add tokens at the modelled 3,000-in / 400-out prediction, cheapest listed model to most expensive:

Three things are worth reading off this table rather than skimming past.

First, cost per prediction is remarkably flat across the three shapes, between half a cent and three and a half cents, while total monthly cost spans two orders of magnitude. Infrastructure is nearly all fixed cost, so what the shapes really differ on is how much idle capacity you are buying. If you are running Shape C at 20,000 predictions a month, your per-prediction cost is 9 cents and you have bought resilience, not throughput. That may be the right purchase. It should be a stated one.

Second, at Shape B the single largest swing factor is not any infrastructure choice. It is the model dropdown, worth $1,215 a month between the cheapest and dearest rows.

Third, none of these totals include the lines nobody publishes a price for: the engineering days to stand it up, the security review, upgrade labour, and an Enterprise quote if identity forces one. Our earlier analysis of enterprise AI implementation cost beyond the license found internal headcount to be the largest single category in a full-stack deployment, at 59% of year-one cost in the scenario modelled there. Flowise does not change that arithmetic; being free to download changes only the smallest term in it.

The Costed Middle Path: Build on Cloud, Run on Your Own Boundary

The choice is usually framed as cloud subscription versus self-host, and framed that way it is a false pair. The shape that most teams should actually cost is a hybrid, and it is cheaper than either extreme for the first two quarters.

Build on the hosted tier. Run production on your own infrastructure. Builders prototype on Flowise Cloud, where updates, backups and the console are somebody else's job, and where the free or entry tier is enough for a handful of people iterating on a canvas. When a flow is approved, it is exported and deployed to your own Apache-licensed instance behind your own identity proxy, pointed at your own Postgres, your own vector store and your own model keys.

Costed, using the same verified figures: one hosted seat's worth of build environment, whatever that turns out to be once you have a quote, plus Shape B at $554 to $1,769 a month for production. The unverified subscription is the only unknown in that sum, which gives you a clean decision rule for the sales call. Ask for the number, add it to $554, and if the total is less than a month of the engineering time you would spend maintaining a second build environment yourself, take the hybrid. If it is more, run one environment and accept slower iteration. What the hybrid buys you is that the expensive, hard-to-reverse decisions, where data lives, whose keys the flow uses, who can see the traces, are made on infrastructure you control, while the cheap, fast-moving decisions happen where iteration is easiest.

What it costs you is honest to state: two environments to keep in sync, an export-import step that is a real migration rather than a button, and the version-skew risk of a hosted build moving ahead of your pinned self-hosted one. For a team of two builders this overhead is not worth it. For a team where a security review stands between the pilot and production, it usually is, because it lets the review happen against the environment that will actually run.

This is the same sequencing argument we made in self-hosted AI deployment: SaaS versus your own cloud. Treat deployment as a progression rather than a one-time fork, and keep the control plane constant across it so that moving does not mean rebuilding.

What the Workday Acquisition Puts on the Risk Line

Flowise is no longer an independent startup. Workday announced on August 14, 2025 that it had acquired Flowise, describing it as "a low-code platform that makes it easy to build AI agents" with "over 42,000 GitHub stars" at the time. The release says Workday is investing in the project's open-source foundation. It does not commit to the standalone product's roadmap, its pricing, or the boundary between the Apache and commercial code.

That is not a prediction that anything bad will happen, and we are not making one. It is a note that belongs on the risk line of a multi-year budget, and the honest framing is a question rather than a forecast: if the commercial edition's feature boundary or price changed in twelve months, what would it cost you to move? The answer depends almost entirely on how much of your logic lives in Flowise-specific node configuration versus in code and prompts you could port.

The repository is, for what it is worth, extremely active. On July 30, 2026 it showed 55,046 stars, 24,796 forks, a push within the previous 24 hours, and 1,034 open issues and pull requests. Read the first three numbers as health and the fourth as maintenance surface. That is a lot of open threads to track if you are pinning versions and reviewing upgrades yourself, which is exactly the labour cost that never appears on a pricing page.

There is a macro version of this same risk worth one line. McKinsey's State of AI survey, published November 5, 2025, found that 23% of respondents were scaling an agentic AI system somewhere in their organization and a further 39% had begun experimenting, while only 39% attributed any level of EBIT impact to AI, and most of those put it below 5%. Stanford HAI's 2026 AI Index reports organizational adoption at 88% alongside AI incidents rising from 233 in 2024 to 362 in 2025. Most agent deployments are still pre-value and the incident count is climbing. Budgeting a tool like this as a multi-year fixed commitment, on either side, is fighting the evidence.

Choose This Shape If: An Explicit Decision Path

Three shapes, three verdicts, stated plainly. Each one is a different answer to the same Flowise pricing question, and the right answer depends on what breaks when the flow does.

Choose Shape A, the prototype, if you are one to three people proving whether a flow is worth building at all, your corpus is internal and non-sensitive, no connector can write to a system of record, and nobody outside the team touches the canvas. Best for: discovery. What you pay: $51 to $294 a month. What is missing: SSO, workspaces, retention beyond 30 days, and any credible answer to a security review. Do not let this shape carry a customer-facing workload, because the shared credential and the local SQLite file are both single points of total failure.

Choose Shape B, single-team production, if one team owns the flows, the workload is internal or lightly external, and you have somewhere to terminate identity in front of the container. Best for: a first real deployment. What you pay: $554 to $1,769 a month, $6,648 to $21,228 a year. What is missing: high availability, since one main and one worker means a deploy is an outage, and per-team separation, since workspaces are outside the free build.

Choose Shape C, the documented HA deployment, if the flows are customer-facing, downtime is a business event, and you need the vendor's own resilience posture rather than a scaled-down version of it. Best for: production you would page someone about. What you pay: $1,898 to $6,760 a month. What is missing: still SSO, unless you have bought Enterprise or fronted it with a proxy at $125 per connection per month.

Choose none of them if your actual requirement is that a business user, not an engineer, changes the flow. Flowise's canvas is drag-and-drop but the concepts underneath it, chains, retrievers, memory types, agent routing, are engineering concepts, and the environment variables, queue mode and Postgres tuning in this article are not optional extras. If nobody on the team will own that, the cheapest correct answer is a managed product with a higher sticker price and a lower operating cost, and no amount of Flowise pricing analysis changes that.

Where the Governance Layer Sits, and What LeapForce Builds

Read the Boundary Bill again and notice which lines are the volatile ones. It is not compute; compute is fixed and boring. It is the model spend that swings 36x on a dropdown, the identity that is not in the free build, and the cost attribution that reads $0.00 when a handler drops a field. Those three are not builder problems, and buying them separately per tool is what makes the total unpredictable. That is the layer LeapForce builds: one governed endpoint in front of every model, so routing, dollar-denominated budgets, and a record of what ran and what was refused are properties of the layer rather than settings inside each canvas. We do not build a visual flow builder and we are not an alternative to Flowise; teams that like the canvas should keep it and put the governed layer underneath. Our published gateway rollout model is Observe first. Enforce second. Optimize third. Start by recording actual model, tool and prompt usage with no rules applied, because you cannot set a budget for traffic you have never measured, and the $0.00 cost field in issue #4779 is exactly what "never measured" looks like in practice. Per our own honesty convention, capabilities on the LeapForce platform are labelled per-capability as LIVE, IN DEV or ROADMAP on the product pages; check the label before you plan around any one of them.

Honest Limits and What We Could Not Verify

Four things in this article are weaker than the rest, and pretending otherwise would make the whole thing less useful.

We did not run Flowise. We have not stood up a cloud tier and a self-hosted instance, run identical workloads through both and published the invoices. That would be the strongest possible version of this piece and we are not claiming it. What we did do is verifiable and reproducible in about twenty minutes: fetch the pricing page and record the redirect, read both license files, list the enterprise directory through the GitHub API, and price every component from its vendor's own page on a stated date. Every number here is a composition of published prices, not a measurement of a real bill.

Flowise's own subscription prices are unverified. The pricing page redirected to a sign-in on July 30, 2026 through all three fetch methods we tried, and the Internet Archive was unreachable from our environment. Figures circulating in secondary coverage may well be accurate; we could not confirm them at the source and therefore do not state them. Treat any Flowise plan figure you read anywhere, including in write-ups more confident than this one, as needing a screenshot from inside an account before it goes in a budget.

The prediction model is an assumption. The 3,000-input / 400-output figure driving the token tables is a plausible retrieval-augmented turn, not a measurement of your flows. Fan-out in a multi-agent flow can multiply it several times over on a single user message. Replace it with numbers from your own traces before this becomes a forecast rather than an illustration.

Render is a stand-in for your infrastructure. We used it because it publishes complete per-instance pricing openly, which most clouds do not. Your figures on AWS, Azure, GCP or a bare VPS will differ, sometimes substantially downward if you are willing to operate the database and cache yourself, at which point the labour cost we listed as unpriceable goes up. The structure of the bill transfers; the specific dollars do not. Total cost of ownership is a shape before it is a number.

One thing we deliberately did not do: rank Flowise against its competitors. Pricing a single tool honestly and picking between tools are different jobs, and mixing them is how a cost analysis quietly becomes a recommendation. The Boundary Bill is a method, and it works just as well on the alternative you are also considering.

Ready to Govern Your AI?

Talk to LeapForce — one controlled layer for every AI tool, connector, model, and agent.