# Flowise Agent Flows on Flat OpenAI Capacity

Point Flowise's ChatOpenAI credential at a flat OpenAI lane: the config, worked cost math for an agent flow that loops and retries, and caps per deployment.

*Published 2026-06-12 · https://proxyllm.ai/blog/flowise-openai-cost-control*

Flowise's ChatOpenAI node accepts a custom base path, which means a flat-rate lane is a credential edit rather than a rebuild. Set the API key to a ProxyLLM key and the base path to `https://api.proxyllm.ai/v1`, and OpenAI-model steps in your flows run through [Codex Hosted](/) on your ChatGPT subscription instead of per-token billing. The graph does not change; the billing model behind it does.

Agent flows are where this matters most, because agent flows loop. Here is the config, the worked math for a loopy flow, and the cap pattern that keeps each bot honest.

## Change the credential, not the graph

In the ChatOpenAI (or OpenAI) node your flow already uses:

```text
OpenAI API Key:  pk_live_your_proxyllm_key
Base Path:       https://api.proxyllm.ai/v1
Model Name:      gpt-5-mini
```

The key goes in the node's credential; the base path sits in the node's configuration. Every flow using that credential now routes through the gateway, where we serve OpenAI-model calls through Codex on your own connected ChatGPT account, log each request, and enforce the key's cap. Connecting the account is a one-time sign-in with OpenAI, run on your own machine.

One scope note: chat-model traffic is what the flat lane serves. Embeddings nodes feeding vector stores stay on your own OpenAI key, which passes through with no markup.

## What a loopy flow actually costs

A tool agent in Flowise turns one user message into a loop: plan, call a tool, read the result, maybe retry, then answer. Each step re-sends the conversation so far, plus tool results, as fresh input tokens.

Worked example: a lead-qualification agent with three tools, averaging 7 model calls per user message at roughly 4,000 input and 300 output tokens per call, on GPT-5 (OpenAI's June 2026 list: $1.25 per million input, $10 per million output):

| Per message               | Arithmetic                   |        Cost |
| ------------------------- | ---------------------------- | ----------: |
| Input                     | 7 × 4,000 = 28,000 × $1.25/M |      $0.035 |
| Output                    | 7 × 300 = 2,100 × $10/M      |      $0.021 |
| **Per message**           |                              |  **$0.056** |
| 400 messages/day, 30 days |                              | **$672/mo** |

Now the part the meter hides until it happens: a tool starts erroring and the agent retries. Calls per message jump from 7 to 12, and the same bot now costs about $0.096 per message, a 71 percent bill increase with zero feature change. A loop that retries is a bill that compounds. The general formula for this multiplication is in [how to calculate AI agent costs](/blog/ai-agent-cost-calculation).

## Flat capacity fits flows that loop

A subscription window prices the conversation, not every step of it. On the flat lane, the retry storm above consumes window capacity instead of generating line items, and your cost for the month stays the plan you already pay.

Sizing honestly: $672 a month sits near the top of a Plus window, which absorbs an estimated $700 of API-equivalent work. The comfortable tier for this bot is Pro 5x: $100 for the plan plus a flat **$129** gateway fee, with roughly $3,500 of estimated API-equivalent capacity, which also covers the next two bots your team ships. Treat window figures as planning estimates, never guarantees; past a limit, calls fall back to a second connected account, then your own API key, and the request log shows the lane per call.

The deeper economics of why agent workloads flip the API-vs-subscription math are in [the agent workload analysis](/blog/chatgpt-subscription-api-for-agents).

## A key per bot

Flowise deployments multiply: the support bot, the lead bot, the internal answerer someone shipped on a Friday. Give each one its own scoped sub-key with a budget cap.

- A flow that starts self-calling hits its own cap and stops, instead of eating the budget every bot shares.
- The request log attributes every call to its key, so per-bot cost review is a filter, not an investigation.
- Raising a cap is a settings change you make after seeing real consumption, not a guess you make before.

One caveat for user-facing embeds: the Codex lane returns complete responses, so a chat widget loses its typing effect and shows the full answer after a wait. Agent steps and internal flows are indifferent to this; a polished customer-facing chat UI may want its streaming path kept on an API-key lane.

Dify users have the same swap with different mechanics, covered in [the Dify guide](/blog/dify-openai-cost-control), and the condensed Flowise steps live on [the integration page](/integrations/flowise). If one of your flows already has a number attached, the [calculator](/calculator) turns it into a plan-tier answer in thirty seconds.