# Which model is cheapest for a customer support chatbot?

> For a customer support chatbot, vibiz/fast (GPT-6 Luna) and vibiz/smart-mini (Claude Haiku 5.5) are cheapest at $0.10 per million input tokens.

**For a customer support chatbot where input context outweighs generated answers, `vibiz/fast` (OpenAI GPT-6 Luna) and `vibiz/smart-mini` (Anthropic Claude Haiku 5.5) are the cheapest options at $0.10 per million input tokens and $0.50 per million output tokens.** If your bot generates long responses relative to short prompts, `vibiz/lite` (DeepSeek V4.1 Flash) is cheaper on output at $0.42 per million tokens, though input costs slightly more at $0.14 per million tokens. Because customer support bots typically ingest large context blocks such as policy documents, past tickets, and conversation histories, input pricing usually drives the total bill.

Choosing the right model for customer service means balancing token pricing, context handling, and strict spending controls. Through thelastapi, you can test and run each of these models using one OpenAI-compatible endpoint.

## Comparing token prices across lightweight models

A customer support bot processes two types of tokens: the prompt (instructions, retrieved knowledge base articles, user query, and conversation history) and the completion (the support assistant's reply). 

Here is how the entry-tier chat models compare on thelastapi:

| thelastapi model | Underlying lab model | Input price (per 1M tokens) | Output price (per 1M tokens) | Context window |
| --- | --- | --- | --- | --- |
| `vibiz/fast` | GPT-6 Luna (OpenAI) | $0.10 | $0.50 | Standard (charges more past 272k tokens) |
| `vibiz/smart-mini` | Claude Haiku 5.5 (Anthropic) | $0.10 | $0.50 | Standard (charges more past 100k tokens) |
| `vibiz/lite` | DeepSeek V4.1 Flash (DeepSeek) | $0.14 | $0.42 | 1,000,000 tokens |
| `vibiz/balanced` | Gemini 3.8 Flash (Google) | $0.825 | $4.125 | 1,000,000 tokens |

For standard support operations, `vibiz/fast` and `vibiz/smart-mini` share identical base rates. Both cost $0.10 per million tokens in and $0.50 per million tokens out. 

However, long context rules differ between labs. GPT-6 models charge more once an individual call's input exceeds 272,000 input tokens. Claude Haiku 5.5 applies a higher rate once input passes 100,000 tokens. If your support bot injects very long transcripts or massive documentation dumps into the context on every turn, `vibiz/lite` avoids those step-ups while offering a 1,000,000 token context window at $0.14 per million input tokens.

To see all available models and their live price books across over 400 language models, run:

```bash
vibiz ai models --all
```

## Calculating the real cost of a support conversation

In support workflows, conversations are heavily skewed toward input tokens. A typical turn includes:
- System instructions defining the agent tone and safety rules (approx. 500 tokens).
- Relevant snippets retrieved from your product documentation (approx. 1,000 to 2,000 tokens).
- Multi-turn conversation history (approx. 500 to 1,500 tokens).
- The user's newest question (approx. 50 tokens).

That totals roughly 2,500 to 4,000 input tokens per turn. In contrast, an effective support assistant usually gives direct, concise answers: between 100 and 250 output tokens.

Suppose a typical user session takes four turns, processing an average of 3,000 input tokens and 150 output tokens per turn:
- **Total input tokens:** 12,000 tokens
- **Total output tokens:** 600 tokens

Using `vibiz/fast` or `vibiz/smart-mini`:
- Input cost: 12,000 × ($0.10 / 1,000,000) = $0.0012
- Output cost: 600 × ($0.50 / 1,000,000) = $0.0003
- **Cost per resolved ticket:** $0.0015 (about one-seventh of a cent)

Using `vibiz/lite`:
- Input cost: 12,000 × ($0.14 / 1,000,000) = $0.00168
- Output cost: 600 × ($0.42 / 1,000,000) = $0.000252
- **Cost per resolved ticket:** $0.001932

Because input makes up over 90% of the token volume in this common support pattern, `vibiz/fast` and `vibiz/smart-mini` produce a lower total bill than `vibiz/lite`, despite having a slightly higher output token rate. You can read more about how gateway routing functions in our guide on [how a unified AI API works](https://thelastapi.dev/blog/one-api-key-gpt-claude-gemini).

## How to call the cheapest models in your support code

thelastapi provides an OpenAI-compatible gateway at `https://thelastapi.dev/v1/ai`. You do not need multiple provider client libraries to test different labs. You point the standard OpenAI SDK at `VIBIZ_AI_BASE_URL` and use your `VIBIZ_AI_API_KEY`.

Here is a support bot handler written in TypeScript:

```ts
import OpenAI from 'openai';

const openai = new OpenAI({
  baseURL: process.env.VIBIZ_AI_BASE_URL,
  apiKey: process.env.VIBIZ_AI_API_KEY,
});

export async function answerCustomerQuery(userId: string, userMessage: string) {
  const response = await openai.chat.completions.create({
    model: 'vibiz/fast',
    user: userId,
    messages: [
      {
        role: 'system',
        content: 'You are Acme Support. Answer concisely using provided context.',
      },
      {
        role: 'user',
        content: userMessage,
      },
    ],
  });

  return {
    reply: response.choices[0]?.message.content,
    modelUsed: response.served_model,
    costMicroUsd: response.cost_micro_usd,
  };
}
```

If you deploy your app with the [@vibiz/app](https://thelastapi.dev/docs/app-sdk) package, client setup requires only the single app key (`VIBIZ_APP_KEY`):

```ts
import { vibiz } from '@vibiz/app';
import OpenAI from 'openai';

const openai = new OpenAI(vibiz.ai);
```

When you decide to compare `vibiz/fast` against `vibiz/smart-mini` or `vibiz/lite`, you only change the `model` string. The gateway routes to that specific model directly. thelastapi never quietly swaps in another model if a service is unavailable; it returns `503 model_unavailable` or `503 provider_unavailable` instead of silently rerouting your traffic to an unexpected, more expensive model. For an in-depth comparison of direct integrations versus gateways, review [OpenAI direct vs model gateway](https://thelastapi.dev/blog/openai-direct-vs-model-gateway).

## Guarding against runaway costs with daily budgets

Customer support bots exposed to public websites face abuse risks: prompt injection loops, script attacks, or scraping. thelastapi includes built-in spending limits documented in [Billing and credits](https://thelastapi.dev/docs/billing) and [Usage and limits](https://thelastapi.dev/docs/usage).

1. **Account daily safety cap:** Accounts start with a default cap of $5 per UTC day across AI and actions, preventing an errant process from exhausting your balance. The owner can raise this in Billing or via `PATCH /v1/billing {"daily_spend_limit_usd": 50}` (up to $1,000).
2. **Project daily budget:** Each project defaults to a $1 daily AI budget. You can adjust this to fit expected traffic:
   ```bash
   vibiz ai budget 15 --project prj_123
   ```
3. **Per-user daily budgets:** By passing a user identifier in the `user` field of the OpenAI request or via the `X-Vibiz-User` header, you can set `end_user_daily_budget_usd`. If a malicious user tries to loop your chatbot, their calls are refused with HTTP `429` (`details.reason: "end_user_budget"`), leaving your bot active for legitimate visitors.
4. **Limit alerts:** Owners automatically receive email alerts when usage reaches 80% and 100% of daily caps.

To inspect how close your support bot is to its budget, use the CLI:

```bash
vibiz usage --by model --period 24h
```

Or view spend broken down by end user:

```bash
vibiz usage --by end_user --project prj_123
```

## Running Google models with your own key

If you have existing Google Cloud credits, you can add your own Gemini key to thelastapi:

```bash
GEMINI_API_KEY=your_key_here vibiz ai keys set google
```

When configured, all Google models (including `vibiz/balanced` and direct IDs like `google/gemini-3.8-flash-tts`) execute on your Google account. Calls to those models cost **$0** on thelastapi. The response returns `"paid_by": "your_key"` along with `would_cost_micro_usd` to display what the call would have cost at list rates. Models from OpenAI, Anthropic, and DeepSeek continue running on thelastapi's prepaid balance as usual. Learn more about evaluating multi-model setups in our guide to [choosing a multi-model API in 2026](https://thelastapi.dev/blog/choosing-a-multi-model-api).

## Next step

To get started, spin up a new project or view documentation on the [AI API](https://thelastapi.dev/docs/ai):

```bash
vibiz init "Support Bot" --resources ai
vibiz dev
```

Test your first prompt directly from your terminal using `vibiz ai "Hello support" --model vibiz/fast` to verify costs and output before launching.

## Frequently asked questions

### Which is cheaper for support, vibiz/fast or vibiz/lite?

vibiz/fast ($0.10/M input tokens) is cheaper for standard customer support bots where retrieved knowledge articles and chat history make input tokens much larger than output tokens. vibiz/lite ($0.42/M output tokens) is cheaper only if your bot outputs significantly more tokens than it reads.

### What happens if an AI model encounters an outage?

thelastapi never swaps models quietly behind your back. If the requested model is unavailable, the API returns a 503 status code with model_unavailable or provider_unavailable and a retry hint so your application can handle the issue deterministically.

### How can I stop a chatbot user from running up my API bill?

Pass a stable identifier in the request's user field and configure end_user_daily_budget_usd on your project. Once the user reaches their cap, the API refuses further calls from them with a 429 rate limit error while keeping the chatbot online for everyone else.

### Do I need separate accounts with OpenAI, Anthropic, and DeepSeek?

No. thelastapi provides access to models across OpenAI, Anthropic, DeepSeek, and Google through one OpenAI-compatible endpoint, one project API key, and a unified prepaid balance.

---

Published 2026-11-15 · https://thelastapi.dev/blog/cheapest-model-support-chatbot
