Most SaaS AI pricing hides token costs inside credits. Nubu connects your own OpenAI, Anthropic or Gemini key, so your provider bills you at raw prices.
Nubu Team··12 minute read
Somewhere on the pricing page of almost every SaaS product that added AI features in the last few years sits the same word: credits. An allowance bundled with your plan. Top-ups when you run out. A small meter in settings, counting down.
What the page rarely says is what a credit is. Not which model your request actually ran on, not what the provider charged for it, and not how much of the credit's price stayed with the vendor on the way through. The unit exists precisely so those questions never come up.
Nubu takes the opposite position, and it is worth stating plainly because it shapes the whole product. Nubu sells no AI credits. Connect your own OpenAI, Anthropic or Gemini key and your provider bills you directly at their prices, with no resale margin. Change model whenever you like; the flows do not change.
This post lays out both models honestly: how credit pricing works and why margins hide inside it, what connecting your own key to Nubu actually does, the rails that keep spend under control, how the AI assistant fits into the same rules, the trade-offs of managing your own provider account, and a short checklist you can apply to any tool that sells AI by the bundle.
How credit pricing works, and where the margin hides#
Strip away the branding and every credit system is the same machine. The vendor holds an API account with one or more AI providers. When you use an AI feature, the vendor's account pays the provider's per-token or per-generation price. Your balance, meanwhile, goes down by however many credits the vendor decided that feature costs. The gap between those two numbers, summed across every customer and every request, is the vendor's AI margin.
Three properties of the model keep that margin invisible.
First, the exchange rate is unstated. A credit has no published conversion to the provider's prices, so you cannot compute what any given action cost at source. The abstraction is the point: it turns an auditable per-token price into a number only the vendor can decode.
Second, the deduction is a product decision, not a market price. How many credits an action costs is set by the vendor, can differ by feature, model and plan, and can be re-tuned quietly. Your effective rate can change without your bill changing shape.
Third, provider price movements do not have to reach you. The underlying model market moves quickly, and when a provider reprices, nothing in a credit system obliges the credit to follow. Any saving between the vendor and the provider is the vendor's to keep or pass on as they choose.
None of this makes credit vendors dishonest, and later in this piece we will give the model its genuine due, because it does suit some teams. But be clear about what a credit is: convenience, with an unstated fee attached, at a rate you cannot audit and did not agree to in any explicit way.
For anything beyond incidental usage, that structure fails the most basic test a finance team applies to any supplier: can we see what we are paying for? With credits the honest answer is no, by design.
AI in Nubu switches on when an organisation owner adds an API key under Settings, Integrations, AI: an OpenAI key, an Anthropic key, a Gemini key, or any combination. Setup guides for each are short reads: connecting OpenAI, connecting Anthropic and connecting Gemini.
Because the key is the whole arrangement, it is worth spelling out exactly what happens to it.
The key is submitted once. Before anything is stored, Nubu tests it live against the provider with a real API call, so a mistyped or revoked key is refused on the spot rather than failing your first build. Only then is it encrypted with AES-256-GCM and stored where the application itself can never read it back. From that moment, the only fragment ever readable again is the last four characters, which is what the settings card shows so you can tell which key is connected. Rotation means replacing the key. For each provider call, the key is decrypted in memory on the server, used, and never written anywhere: keys do not appear in logs, error messages or prompts.
From then on, every AI request Nubu makes on your organisation's behalf runs against your provider account. The provider meters it at the same raw prices you would pay calling the API yourself, and bills the payment method on your provider account, not ours. There is no resale step for a margin to hide in, because the money never passes through Nubu at all.
The second half of the stance is model freedom. Because requests run on your key, model choice is yours: owners set the default provider and model per task, can restrict the team to that default or leave the pick open, and can change their mind whenever a provider ships something better or cheaper. The flows do not change. The same graph that translated copy on one model translates it on the next; you re-point the setting, not the work.
That freedom matters more than it first appears. In a credit system, the vendor chooses which models you get and when, because every model choice changes their margin. On your own key, a new model is available to you the moment your provider offers it and Nubu supports it, with no repricing negotiation in between.
A transparency claim is only as good as the reporting behind it, so here is exactly how visibility splits between Nubu and your provider.
Nubu keeps usage records as metadata only: which task ran, on which provider and model, token counts, cache hits and error codes. No prompt text and no output text is stored in those records; there is simply nowhere in them for it to go. Records are kept for around 90 days and then folded into monthly totals, so long-term reporting stays available without long-term retention of fine-grained rows. The assistant additionally records its own usage against every run it performs, so a conversation that did work leaves an itemised trail of the calls it made.
Token-level cost reporting lives in your provider's own dashboard, and that is not a gap in the product. It is the point. Your OpenAI, Anthropic or Gemini console shows spend measured by the party actually charging you, at the prices they actually charge, alongside whatever billing limits and alerts you have configured there. There is no second ledger denominated in a vendor's invented currency, and nothing to reconcile it against. Your API dashboard is our bill.
That arrangement puts cost control where it belongs: with whoever controls the API account. Your finance team can read the provider's invoice without a decoder ring. Your engineering lead can set hard limits on the provider side that no tool, Nubu included, can spend past. And if you ever want to stop all AI spend instantly, you can revoke the key in your provider console and the meter stops with it.
The control rails: budgets, confirmation, caching#
Direct billing without controls would simply relocate the anxiety, so the same settings page that holds your keys holds the rails. All of them are owner-set, under Settings, Integrations, AI.
Weekly budgets, four lanes. Owners can set a weekly AI request budget, a weekly image generation budget, a weekly video generation budget, and a separate weekly assistant budget. Each is optional; leave one unset and that rail is off. The lanes are separate because the costs are not alike: a video generation is a different magnitude of spend from a text request, so a single blended cap would either strangle text work or fail to protect you from video. One detail shows the care taken here: video generation charges its budget at the moment the generation starts, so a build that pauses and resumes can never charge the same clip twice.
Confirmation before spend. Nothing in a build spends silently. When you press Build, Nubu first works out the exact set of AI requests the build actually needs, already excluding everything it can reuse from earlier runs, and asks you to confirm before anything runs. You see the real count, not an estimate, and image and video generations are counted out separately in that dialog because they cost more. Approve it and a persistent progress toast follows the batch while you carry on working elsewhere in the app; closing the tab only pauses the work, and nothing is ever charged twice.
Hard caps as a backstop. Independently of your budgets, one build can make at most 1,000 AI requests, of which at most 100 may be image generations and 25 video generations. Caps are not there to be hit; they are there so that no misconfigured graph, however enthusiastic, can turn into an unbounded bill.
Caching, the quiet one. Every AI result is cached, and a build never pays twice for the same work. The consequence is easy to say and easy to underestimate: rebuilding an unchanged graph re-spends nothing. Change one line of copy and only the requests that depend on it run again; everything untouched is a cache hit at zero cost. In day-to-day use, where teams iterate on a flow dozens of times before sign-off, this is the single biggest saving in the system, and it exists by construction rather than by discipline.
Pass-through where AI adds nothing. The translate node routes copy into any language your connected model can write, but routes marked as the original language pass straight through with no AI request at all. You pay to translate, never to leave something alone. There is more on how translation fans one flow out across markets in Translate video ads at scale.
The pattern across all five rails is the same: spend is visible before it happens, capped while it happens, and avoided entirely where the system can prove it is unnecessary. If you want the mechanics in more depth, using AI nodes covers them.
Nubu also ships an AI assistant that can search your workspace, draft campaigns and flows, check copy and generate media in chat. In a credit-priced product, an agent like that is exactly where surprise bills come from: it makes many calls per conversation, and each one quietly drains the meter at an unknown rate.
In Nubu the assistant has no separate meter and no separate price list. It runs on the same connected keys, under the same rules, the same model settings and the same caching as everything else, and its spend answers to the same settings page. The weekly assistant budget is its own lane, counted per run, so a heavy week of conversation cannot eat the budget your production builds rely on, and vice versa.
On top of the shared rails, the assistant carries two disciplines of its own. Its generation tools are deliberately tight: within one run it will generate at most 4 images and 2 videos. And before its first generation for a request it stops and asks you to confirm the brief, even when the request already reads like a complete one, rather than generating straight away. The expensive step always has a human in front of it.
You can watch that discipline in a single exchange. Ask for media:
Generate three lifestyle images of the Aurora range for the spring teaser, warm morning light, nothing text-heavy.
The assistant does not start generating. It restates the brief, offers a model choice where more than one could run it, and asks you to confirm before the first image is made. Only then does your key spend, and the results land as ordinary tagged assets in the library, not as chat ephemera.
It is also worth saying what the assistant cannot do: it has no tools to render, publish or delete anything. Changes it drafts land as proposals that a person reviews and applies. That design is covered properly in AI proposes, humans approve, and the assistant's full capabilities in the AI campaign builder piece, but the economic consequence belongs here: an agent that cannot commit spend beyond small, confirmed, capped generations is an agent you can leave switched on.
Because the assistant records its usage against every run, the trail is always there: what a conversation did, on which models, with which cache hits. Same keys, same budgets, same visibility. It is also a trail you can simply ask for, in the window where the work happened:
What did the assistant do in this chat so far?
The reply is an itemised account of the conversation's runs, the calls it made, the models that answered and the token counts included, no export required. An assistant priced in credits is a liability meter; an assistant on your own key is just another workload you already control.
Bring-your-own-keys is the right model for teams spending real money on AI. It is not free of obligations, and pretending otherwise would undermine the point of this piece.
You manage a provider account. Creating the account, attaching a payment method, setting provider-side limits and living within the provider's rate limits is your responsibility. If a key hits its own spending cap or the provider throttles you, that surfaces in your builds as an honest error, immediately, with no silent retries burning further money behind the scenes. It is yours to fix, because the account is yours. For most teams this is one afternoon of setup and occasional housekeeping; it is still work that a credit bundle would have hidden from you.
AI features sit on the Business+ plan. Keys, the AI nodes and the assistant are part of Nubu's Business+ tier. Nubu's own subscription is a separate, public price on the pricing page; it pays for the platform and it does not scale with your AI usage. The two costs never blur: the subscription is Nubu's, the tokens are your provider's.
Credits genuinely suit some teams. If your AI usage is a handful of small requests a month, a bundled allowance spares you a provider account, a second supplier relationship and any thought at all. The margin inside the bundle is the fee for that simplicity, and at tiny volumes it is a fair trade; the absolute cost of the markup rounds to nothing. The model breaks down with scale: an unstated percentage of a growing bill grows with it, and the point where convenience stops being worth the fee arrives sooner than most teams expect. Direct billing takes the same share at every volume: none.
Whichever tools you are evaluating, ten questions separate transparent AI pricing from the other kind, usually within one demo call.
Who does the AI provider bill: us, or the vendor? Everything else follows from this answer.
Is the markup stated? If AI is resold, the honest version prints the margin. Silence is an answer too.
Can we compute the source cost of one action? If the unit is an abstraction with no published conversion, you cannot.
When the provider cuts prices, does our cost fall automatically? On your own key, yes, the same day. In a bundle, ask who decides.
Can we change model without changing our workflows? Model freedom is what keeps you on the right price-quality point as the market moves.
Can spend be capped before it happens? Budgets that block a run beat alerts that arrive after the invoice.
Are we shown the request count and asked before a batch spends? Consent per batch, with a real number, not a vibe.
Does re-running unchanged work cost again? Caching by construction is worth more than any discount.
What is stored about our prompts and outputs, and for how long? Metadata-only logging with a stated retention period is the answer you want to hear.
If we leave, what stops the spend? A key you own can be revoked in your provider console in seconds, whatever the vendor does.
Nubu's answers are the ones this post has already given, and we would encourage you to ask every one of these questions of us too, on a call, with your finance lead listening. The questions only feel uncomfortable when the pricing has something to hide.
The argument for bringing your own keys is not ideological. AI is becoming a real line item in creative production, and real line items need what every other supplier relationship already has: an itemised bill from the party doing the work, prices that move with the market, and controls in the hands of whoever owns the account. Credits were a reasonable bridge when AI features were a novelty. At production volume, they are a margin wearing a simplicity costume.
Nubu's version is short enough to repeat: your keys, your provider's prices, your budgets, confirmation before spend, caching so unchanged work is free, and an assistant bound by the same rules. Your API dashboard is our bill.
If that sounds like the right arrangement, the pricing page at /pricing has Nubu's own numbers in public, and you can create a workspace, connect a key and watch your own provider dashboard meter your first build.
