Which API Providers Offer Gemini 3.8 Flash and Discounted Open-Weight Models on One Bill?

Savings come from how traffic is allocated: Gemini 3.8 Flash stays the main model, and the work that does not need it moves to open models that carry a discount badge. GMI Cloud MaaS serves Gemini 3.8 Flash and the badged open models DeepSeek-V4-Pro, GLM-5.3, and MiniMax-M3 on one API key and one endpoint, and every model lands on a single MaaS invoice, with no second vendor account.

In GMI's model library the discount badges sit on open models: DeepSeek-V4-Pro shows 45% off, and several other open models carry badges between 20% and 40%.

What the model library shows today

The public model library in the console opens without a login. It lists Gemini 3.8 Flash as a Google LLM card and shows these discount badges on open models:

The library also lists many other open models and proprietary model families.

How to read a discount badge

A 45% off badge does not say the model costs 45% less than another model, and it does not compare a DeepSeek model with Gemini 3.8 Flash. Two models with the same badge can have very different base rates.

Blended cost follows the share of requests each model handles and the rate each model charges for the tokens you actually send. A rough way to estimate it:

1. Run a representative sample of your requests and record the input and output tokens each model uses, from the usage field in each response.
2. For each model, take the current input and output rates and any region modifier shown on its model library card, which is where the pricing documentation places them, and keep input and output rates separate.
3. Convert the token counts from step 1 into the unit each rate is quoted in, multiply input and output separately by their rates, and include retries and any calls escalated to a second model.
4. Compare the total with the cost of running the same task set on Gemini 3.8 Flash alone.
5. After the test run, replace the estimate with the per-model spend that Serverless Usage shows for it.

Volume pricing and custom agreements for your own account go through the sales team. Use your real prompt and completion sizes, not a round-number average. If a discounted model needs longer prompts or more retries to reach the same quality on your task, the saving shrinks, so test the split on real requests before it goes live.

A routing table in config

Because every model sits behind the same endpoint, the split is a configuration choice. The base URL is https://api.gmi-serving.com, the chat completions route follows the OpenAI request format, and as the developers page puts it, you keep your code and change the model ID. A minimal routing table with the OpenAI SDK looks like this:

# pip install openai
from openai import OpenAI, APIError, RateLimitError

client = OpenAI(
    base_url="https://api.gmi-serving.com/v1",
    api_key="<GMI_API_KEY>",
)

# Model IDs live in config, so switching models needs no code change
ROUTES = {
    "primary": "<GEMINI_38_FLASH_ID>",
    "cost_side": "deepseek-ai/DeepSeek-V4-Pro",
}

def call(tier: str, prompt: str) -> str:
    reply = client.chat.completions.create(
        model=ROUTES[tier],
        messages=[{"role": "user", "content": prompt}],
    )
    return reply.choices[0].message.content

def ask(prompt: str, check) -> tuple[str, str]:
    """Try the open model first; escalate to the primary model on an
    API error or when your own check() rejects the output."""
    try:
        text = call("cost_side", prompt)
        if check(text):
            return text, "cost_side"
    except RateLimitError:
        raise  # a 429 calls for backoff and retry, not escalation
    except APIError:
        pass
    return call("primary", prompt), "primary"

The models on your key are listed with one request:

GET https://api.gmi-serving.com/v1/models
Authorization: Bearer <GMI_API_KEY>

The deepseek-ai/DeepSeek-V4-Pro ID is the one the developers page uses in its own request samples, and the Gemini 3.8 Flash ID goes into the same config. The function returns the tier that answered, so your application can log how many requests were completed by the primary model after the open model's output was rejected or errored.

The LLM API reference documents the chat completions fields, including messages, tools, stream, and response_format.

How to split work between the two sides

With fixed model IDs, your application decides which requests go where. Quality differs by task, so treat this as a starting split and tune it on your graded sample.

A workable pattern is a two-step ladder. Send the request to the discounted open model first, and escalate to Gemini 3.8 Flash when a check fails, such as an invalid schema or a low-confidence label. Only the failures reach Gemini 3.8 Flash. Whether the ladder saves money depends on your escalation rate, which your application logs can measure on a representative sample.

Models from the same family can be tested against each other as well. The library shows DeepSeek-V4-Pro and DeepSeek-V4-Pro-0813 as separate cards with different badges, and GLM-5.3 and GLM-5.3 Flash likewise. Pick the variant that holds up on your sample; badge size does not decide it.

Reading one bill that still splits

Every model on the key lands in one total, which is hard to act on by itself, so the console lets you break it apart. Open Billing, then Serverless Usage, where the usage view can be narrowed by API key and model name.

Serverless Usage filter: set the API key and model name fields to see how much of the bill each side of your split produced.

Per-workload keys and the model filter show the split:

• One key per workload. Give the support assistant, the batch pipeline, and the evaluation harness their own keys. Each key becomes a cost center even when they share models.
• Read the model filter on a schedule. Filter by model name to see the share of volume on Gemini 3.8 Flash versus the discounted open models. If the open side carries far less than you planned, check your application's routing logs for a higher escalation rate or a rule that is not being applied; token share can also shift with output length and retries.

Chat completion responses also carry token usage, so your application logs can be compared with the usage view for the same key, model, and time window.

Before you move production traffic

• Plan for rate limits. Inference limits are set by usage tier and enforced at the organization level, so separate keys for separate workloads share your organization's limits. The rate limit documentation lists the usage tiers and their limits. The OpenAI SDK retries connection errors, 429s, and 5xx responses twice by default before it raises, so the handler above runs after those retries; set max_retries on the client to change that. The handler re-raises a 429 so your own backoff can take over, and escalates on other API errors.
• Run the same graded sample through each model. Use your tool definitions, response formats, and prompt lengths, and read the results against the checks in the placement table: label agreement, schema validity, tool-call accuracy, and edit rate.
• Set service terms for your plan. For production traffic, MaaS provides guaranteed SLAs with uptime and performance commitments, zero-retention configurations for sensitive workloads, and per-client customization across pricing, policies, and deployment.
• Dedicated endpoint when latency matters. Once the first requests work, a dedicated endpoint is the step for fixed latency.

If you would rather not hard-code the split, GMI Router selects a model for each request from the pool you allow, and it is free during preview. Checks such as schema validity run in your code, so keep them there.

FAQ

Can several teammates work in the same GMI account and still land on one bill?

The organization owner opens Member List and uses Invite Members to add each teammate by email. Everyone then creates keys for their own workloads inside that organization, and the usage stays on the organization's single invoice. Serverless Usage still splits it by API key and model name. Ownership can be reassigned from the same page, and a member can be removed from the dropdown.

If the open-model side moves to a dedicated endpoint later, where does its cost show up?

Billing has a Dedicated Usage view next to Serverless Usage, opened from the same Billing dropdown. It offers the same filters: time range, daily or hourly granularity, API key, and model name. Gemini 3.8 Flash stays in Serverless Usage while the migrated open models appear in Dedicated Usage, so each side keeps its own view under one account. Rates for both deployment types sit on the model cards under Inference > Model Hub.

Run the graded sample on Gemini 3.8 Flash and one badged model

Send the same graded sample to Gemini 3.8 Flash and to one badged open model, using a key created in the GMI Cloud console. Commercial terms for your volume, uptime commitments, or a zero-retention setup are a conversation with GMI sales.