Cut AI SaaS API Costs with OpenRouter, Ollama and DeepSeek

For most AI SaaS businesses, the biggest line on the monthly bill is not hosting or payments. It is the model API. Every message a subscriber sends costs you something, and the cost depends heavily on which model answers it.

The good news is that you control more of that bill than it seems. The price gap between a frontier model and a capable budget model is wide, and for a lot of everyday requests users cannot tell the difference. This post covers how to use that gap: price each model on its own, put cheap models where they belong, and add lower-cost sources such as OpenRouter, DeepSeek and local models through Ollama.

We will not quote provider prices here, because they change often and any number would be out of date soon. Check each provider's own pricing page when you set your rates. The approach below works whatever today's numbers are.

Why API Costs Get Out of Hand

Three patterns drive most runaway API bills in AI SaaS products.

One model for everything. The app sends every request, from "hi" to a fifty-page analysis, to the most capable model available. That model is often many times more expensive than a budget model that would have handled most of those requests just fine.

Flat pricing on variable costs. A plan with "unlimited" messages for a fixed price works until a few heavy users arrive. Your revenue per user stays flat while your cost per user keeps climbing.

Hidden background calls. Chat titles, prompt rewriting, summaries and other helper calls each cost a little. Sent to an expensive model, they add up without anyone noticing.

The fix for all three is the same: meter usage in a unit you control, and choose the model for each job on purpose.

Price Every Model on Its Own

The foundation is per-model credit pricing. Instead of charging subscribers in raw tokens, you sell credits, and you decide how many credits each model spends per unit of usage.

In Aikeedo, this lives under Settings → Credit ratios. Every model has its own rate, with separate input and output rates for text models, and images, video seconds and speech characters have their own too. The effect is simple:

• Expensive models spend credits quickly, so a heavy user of a frontier model pays for that choice, and your margin holds.
• Cheap models spend credits slowly, so the same balance goes much further, and users are nudged toward models that cost you less.

Set rates from your real costs plus the margin you want, and review them when providers change their prices. A few practical points:

• Start from cost, not from what feels fair. Work out what a typical request costs you on each model, then set the credit rate so that the credits it spends are worth more than that at your plan prices. The AI SaaS profit calculator helps with the arithmetic, and commercial license holders get a credit ratio calculator linked from the Credit ratios page.
• Keep input and output rates separate. Output tokens usually cost more than input tokens, and long answers are where costs build up.
• Use estimates. Aikeedo shows users an upfront credit estimate for many tasks, so they see that a premium model costs more before they press the button.

For a deeper look at pricing models, see how to price an AI SaaS product.

Put Cheap Models on Free and Entry Tiers

Free tiers are where many AI products lose money. Every free user costs real API spend, and most of them will never pay. You still want a free tier, because it is how people discover your product. The trick is to make it cheap to run.

Aikeedo plans can allow all models or a hand-picked list. That gives you a simple structure:

• Free plan: one or two low-cost models, such as DeepSeek or a small open model, with a modest credit allowance. You can give new sign-ups a free plan automatically and use it as the fallback when a paid subscription ends.
• Starter plan: the budget models plus a mid-range model, with more credits.
• Pro plan: everything, including frontier models, web search, connectors and other premium features.

Because plans can also switch individual tools on or off, you can keep the costly parts, such as video generation, out of cheaper tiers entirely. The free tier still shows off your product; it just does so on models that cost you a small fraction of the premium ones.

Upgrades follow naturally. A user who outgrows the free model has a clear reason to pay: better models, more credits, more tools.

Watch the helper calls

Background tasks need a model too, and the defaults are worth checking. Under Settings → Features → Utilities you choose the model that writes titles for chats, images and other content, and the model used for prompt enhancement and the "Surprise me" prompt. Both are billed like any other model. A budget model usually does these jobs well, though for titles in languages other than English a more capable model can be worth it. Whether workspaces are charged for these helper calls is a separate choice in the billing settings.

OpenRouter: Many Models Behind One Key

OpenRouter is a gateway that gives you access to models from many providers through a single API key and a single bill. For cost control, it is useful in a few ways:

• Try before committing. You can add a new low-cost model the day it launches, see how your users respond, and only then decide whether to open a direct account with that provider.
• Open models without hosting. OpenRouter offers many open-weight models, such as DeepSeek, Qwen, GLM and Mistral models, so you can offer cheap options without running GPUs.
• One account to manage instead of a dozen.

In Aikeedo, OpenRouter is one of the ready-made presets for custom LLM servers, which you can bring in with the starter content. Open it under Custom LLM Servers in the admin settings, paste your key, then import and enable the models you want under Settings → Models. The preset comes with a starting set of models, and you can add more.

The trade-off: a gateway can cost a little more than going direct for the models you use most, and it adds a dependency. A common setup is to use direct keys for your two or three most-used models and OpenRouter for the long tail. Aikeedo lets you mix both freely.

DeepSeek: Low-Cost Reasoning

DeepSeek has built its reputation on capable chat and reasoning models at low API prices, which makes it a natural choice for free tiers, budget plans and high-volume use.

It connects the same way as OpenRouter, through a ready-made OpenAI-compatible preset. Create a key on the DeepSeek platform, add the DeepSeek preset, paste the key under Custom LLM Servers, and enable the models under Settings → Models. Because DeepSeek's open models are also available through OpenRouter and can run locally on Ollama, you have three ways to offer them and can switch between them if one becomes cheaper or more reliable.

DeepSeek and OpenRouter are only two of the presets. Others include Groq, Together AI, Mistral AI, DeepInfra, Cerebras, Hugging Face, Nebius, Moonshot AI and Google AI Studio, and any other OpenAI-compatible server can be added by URL and key. More sources means more room to pick the best price for each job.

Ollama: Fixed Costs with Local Models

Ollama runs open models, such as GPT-OSS, Gemma, Qwen, Llama and DeepSeek R1, on hardware you control. Instead of paying per token, you pay for the server.

That changes the shape of your costs:

• Per-token API spend: none for those models.
• Server cost: fixed, whether users send ten messages or ten thousand, up to what the hardware can handle.
• Privacy: prompts and answers never leave your infrastructure, which matters for some customers.

To connect it, install Ollama on a server and pull the models you want, then open Ollama under Custom LLM Servers in the Aikeedo admin settings, enter the server address and enable the models under Settings → Models. Ollama does not need to run on the same machine as Aikeedo; a separate GPU server is typical. Ollama also provides embeddings, so assistant knowledge bases can run locally too. The Ollama docs cover the setup in detail. One caution from them: Ollama has no authentication by default, so do not expose it to the open internet without securing it.

Local models make the most sense at steady, predictable volume, or when privacy is a selling point. At low volume, a pay-per-use API is usually cheaper than keeping a GPU server running. Run the numbers for your own traffic before you buy hardware.

A Cost-Conscious Setup, Step by Step

Putting it together, a typical setup looks like this:

1. Connect one premium provider directly, such as OpenAI or Anthropic, for your top tier.
2. Add DeepSeek and OpenRouter through the custom LLM server presets for budget and long-tail models.
3. Optionally add Ollama if you have steady volume or privacy-minded customers.
4. Set credit ratios for every model from real costs plus margin.
5. Build plans around model access: budget models for free and starter, everything for pro.
6. Point helper tasks at a budget model under Features → Utilities.
7. Review monthly. Compare usage and revenue reports in the admin, check provider prices, and adjust rates.

Two more features can help at the edges. Bring your own key lets workspace owners add their own OpenAI or Anthropic key, with credit rules you define, which suits heavy users who would otherwise be expensive to serve. And credit packs let users who run out top up rather than forcing you to give away usage.

FAQ

What is the cheapest way to reduce OpenAI API costs?

Stop sending every request to your most expensive model. Price models individually in credits, give free and entry plans access only to low-cost models, and use a budget model for background tasks such as titles. Most of the saving comes from those three changes.

Is OpenRouter cheaper than using providers directly?

Not always. A gateway can cost slightly more for a given model than the provider's own API. Its value is access to many models through one key. Many operators use direct keys for their most-used models and OpenRouter for everything else.

Is a local model with Ollama really free?

There is no per-token bill, but you pay for the server that runs it, and capable models need capable hardware. Ollama tends to pay off at steady volume or when privacy is part of what you sell. At low volume, a cheap API model usually costs less.

Will users notice if free plans use cheaper models?

Users notice what they can do, not which provider answers. Budget models handle everyday chat, writing and summaries well. Keep frontier models as a clear reason to upgrade, and show credit estimates so users understand the difference in cost.