Bring your own API key vs bundled pricing

The two models in one paragraph

Bundled pricing bakes the cost of the models into your subscription: one price, the vendor buys the tokens and resells them to you inside the plan. Bringing your own key means the tool calls the model with your own API key and you pay the provider's published token prices directly, so the software fee and the model cost stay separate bills.

An API key is just the credential a tool uses to call a model in your account. You generate it in the provider console, paste it into the tool once, and every run the tool makes lands on your provider bill at whatever that provider charges per million tokens. Nothing about the arrangement is technical once the key is pasted; the rest is an accounting question.

How each one actually bills

Bundled plans bill a fixed subscription or a pool of credits with model cost assumed inside the price. A bring-your-own-key tool bills a software fee plus metered tokens at the provider's own rate, with nothing added on top.

The bundled bill is easy to predict and hard to audit: you pay the same in a quiet month, and the price already contains the vendor's guess about how much you will use, plus their margin on the tokens. Past the plan's allowance the shape shows up as prompt caps, per-engine add-ons, credit top-ups, or throttling, all of which land after you are already committed.

The bring-your-own-key bill is the opposite: auditable to the token, because the provider dashboard shows exactly what each run consumed, but different every month. Your software fee stays flat; the token line follows your run count, your prompt lengths, and whichever engines you switched on.

The break-even arithmetic

The crossover sits where the bundled plan's overage charges exceed what the same tokens cost at the provider. Below it the bundle is cheaper or equal and certainly simpler; above it the vendor's margin compounds with every run.

Real token prices differ by provider and model, and each provider publishes its own rate card, so run the arithmetic with the numbers you would actually pay. The shape of the answer holds regardless: the bundle buys certainty, bringing your own key buys the meter.

Costs that never reach the invoice

Each model has a bill you do not see on the payment screen. Bringing your own key charges you in operations; bundled pricing charges you in constraints.

What bringing your own key asks of you

Someone has to hold the keys. That means creating them per provider, storing them safely, rotating them when a contractor leaves, setting spend limits so a broken schedule cannot run the bill up overnight, and checking the provider dashboard monthly. Usage also swings: add ten prompts or a fifth engine and the token line follows, so finance gets a variable cost instead of a fixed one. The teams who do badly with their own key are the ones with nobody assigned to any of that.

What bundled pricing hides

Margin on tokens is the obvious one, and it grows with you. Then come the structural limits: prompt caps per tier, engines sold as paid add-ons so “tracks seven engines” turns out to be a configuration rather than your plan, credits that expire before a slow quarter uses them, and annual contracts that lock in an assumption about your volume made on the day you signed.

Who each model suits

Bundled suits low, predictable volume and teams who want one invoice. Bringing your own key suits high run counts and teams who already pay a provider and can name the person watching the spend.

If you track a handful of prompts weekly and nobody on the team wants another console to log into, the bundled premium is buying you something real: a flat bill and no key hygiene. If you run daily across several engines, or a client portfolio multiplies your prompt count, the same premium becomes a tax on scale, because the vendor pays token prices and charges you a blended rate built on average usage that is not yours.

A tell worth knowing in demos: ask what the plan assumes about your usage and what happens the month you double it. A bundled vendor should name the cap and the overage; a bring-your-own-key vendor should name their software fee and confirm there is no markup on the tokens. Evasion on either question is the answer.

How advisible handles provider keys

Keys live per workspace, runs bill at the provider's published token prices with no markup, and a missing key pauses that engine instead of quietly spending someone else's money.

• Workspace keys only, encrypted at rest. Each workspace holds its own key for ChatGPT, Perplexity, Gemini, Grok and Claude, stored encrypted. There is no platform or environment fallback, so no customer run can ever spend the operator's credit.
• Runs pause without a key. A missing key skips that engine's runs before they exist, and Run now names the engines it skipped. Nothing is simulated to fill the gap.

The trade-offs in this article are the same ones we live with: you get the meter, and you hold the key. Setup takes about ten minutes, and the volume question resolves itself in the provider dashboard after the first week. Start from free ways to track AI visibility if you have not built a prompt list yet.