Which API Providers Give You Discounted GPT-6 Astra Access and Image and Video Models in One Account?

The worked monthly workload—132M LLM tokens, 20,000 images, and 600 eight-second clips—costs $2,889.60 at the cited undiscounted rates, or $1,664.88 after routing part of the text workload to a cheaper model. GMI Cloud MaaS combines GPT-6 Astra, image, and video models under one organization, invoice, and usage view. Rates are from October 15, 2026; the calculation below separates model pricing from routing savings. (GMI Cloud's Model-as-a-Service (MaaS) platform)

MaaS provides LLM, image, video, and audio models through unified APIs, with per-client pricing and deployment options.

Astra had no catalog promotion on October 15, 2026: its $10/$50 per 1M input/output rates matched GMI's briefing of OpenAI API pricing. The worked savings instead come from cache reads, request tiers, cheaper routed models, and negotiated terms. (GMI Cloud model library; OpenAI's API)

What does "discounted access" actually mean on a model API?

Discounted access on a model API comes from four separate mechanisms: time-limited catalog promotions, price structure inside the model itself such as cache read rates and input tiers, per-client negotiated pricing, and the model mix you route traffic across. They stack, and they are worth separating before you compare providers.

Catalog promotions are the only one of the four that expires, so do not build a budget on them. Model the workload at the undiscounted rate, then treat any live promotion as upside. Every figure below follows that rule.

Which models are discounted on GMI Cloud right now?

Live GMI Cloud catalog promotions on October 15, 2026 covered sixteen LLM model IDs, including DeepSeek-V4-Pro at 45% off and DeepSeek-V4.1-Flash and GLM-5.3-Flash at 40% off, plus the GPT Image 2 generate and edit endpoints at 20% off. Below are the ones a mixed workload is most likely to route to, read from the GMI Cloud model library on that date. Promotions change, so re-check the library before you commit a number to a plan.

This is the concrete version of the MaaS page's claim of "Discounted pricing for major proprietary models like GPT, Claude, Gemini, Qwen, Kling and more." Eighteen active model IDs on promotion on one ordinary Thursday is the point: the discount surface moves week to week, and it sits in the same catalog as the frontier model you came for rather than in a separate account you have to open first.

How do you cut a GPT-6 Astra bill when Astra itself is not on promotion?

Three levers lower a GPT-6 Astra bill without any catalog promotion on Astra itself: routing non-frontier work to cheaper models in the same catalog, paying the $1.00 cache read rate instead of the $10.00 input rate on repeated prefixes, and keeping requests under the 272,000-token tier boundary. The worked bill below puts a figure on the first one; the other two apply on top of it.

Lever 1: send Astra only the work that needs Astra. In the worked bill in the next section this is worth $1,224.72 a month, against $14.11 from the live promotion on the same rerouted traffic. Astra's context window is 1,050,000 tokens, which invites teams to route everything through it. Classification, extraction, reformatting, and first-draft generation rarely need a frontier model, and the discounted Flash tier sits in the same catalog behind the same key. If you would rather not hand-pick the destination per call, GMI Router selects a model per prompt from a curated pool of GMI Cloud hosted models.

Lever 2: pay $1.00 instead of $10.00 for repeated prefixes. Astra's listed cache read price is $1.00 per 1M tokens, one tenth of the $10.00 input rate, with cache writes at $12.50 per 1M. That write premium sets a clean break-even. A cached prefix costs $12.50 to write plus $1.00 per read, against $10.00 per read uncached, so the two are equal at 1.39 reads. From the second read onward, caching the prefix is cheaper. For a 20,000-token system prompt and tool schema read 10 times, that is $0.25 to write plus $0.20 in reads, against $2.00 uncached, a 77.5% cut on that prefix. Measure the result on the Console usage view rather than in your client, since GMI Cloud's LLM API reference does not document a cache-hit field in the response.

Keep assembled request input at or below 272,000 tokens when practical. Above that threshold, Astra lists $20/$75 per 1M input/output and $2 cache reads. A 300,000-token input costs $6.00 versus $2.72 at 272,000—a 9% token reduction cuts input cost by 55% and returns output to $50/1M. Count system text, tools, and history before sending; summarize excess context on a cheaper model if appropriate. The inference-cost-per-million-tokens guide explains the mechanics. (GMI Cloud's breakdown of inference cost per million tokens)

What do image and video actually cost in the same account?

The media models a cross-modal product reaches for most often were listed in the GMI Cloud model library at $0.01325 to $0.085 per image and $0.05 to $0.40 or more per second of video on October 15, 2026, with other models in the catalog sitting outside that span in both directions. The trap in those numbers is not the discount, it is the unit: a per-second or per-image headline rate is usually one cell of a matrix, and the cell the catalog advertises is often not the cell your default parameters land in.

Two rows deserve a second look. Seedance 2.0 advertises $0.07 per second, but that is the 480p rate, and the documented default resolution is 720p at $0.152 per second, so an 8-second clip on defaults costs $1.22 rather than $0.56. The GPT image 2.5 entry is sharper still: the default quality is medium at $0.0132 per image, while leaving quality out of the request bills at the max tier, $0.2107, a 16x difference driven by one absent JSON field. Set quality and resolution explicitly in every media call, and audit a week of requests against the catalog rates before you scale. For a practitioner read on how these image models behave in production, see GMI Cloud's test notes on Hy Image 3.5 Preview.

What does a combined monthly bill look like?

A mid-size content product running 120M input and 12M output tokens of LLM work, 20,000 images, and 600 eight-second clips per month bills $2,889.60 with all text on GPT-6 Astra, and $1,664.88 once 70% of that text volume moves to a cheaper model in the same catalog. Everything below is at undiscounted rates as listed in the GMI Cloud model library on October 15, 2026, and everything is in one account. The media lines assume quality and resolution are set explicitly: medium 1024x1024 on the GPT image line, Seedream Pro at its default 2048x2048, and 720p on the clips. Defaults and omissions bill differently. The draft-image line is priced at the catalog's $0.01325 per-image headline rate, which covers image output. Prompt text on those calls is billed separately at $5.00 per 1M tokens, so budget it explicitly: at 16,000 images, every 100 prompt tokens per image adds $8.00 to the month, and a 1,000-token prompt template adds $80.00.

Baseline, all LLM traffic on GPT-6 Astra:

After moving 70% of LLM volume to deepseek-ai/DeepSeek-V4.1-Flash:

That single routing decision removes $1,224.72 a month, 42% of the whole bill, and it is available because both models sit in the same catalog behind the same key. On top of it, the Flash line was listed at 40% off on October 15, 2026, which would price those two rows at $21.17 instead of $35.28 while that promotion runs, and cache reads on the remaining Astra traffic take the $360.00 input line down further. Budget at $1,664.88 and treat the rest as upside.

Note what the media lines do: $1,089.60 of a $1,664.88 bill is images and video. At this asset volume, media is the larger half of the bill once text is routed sensibly, which is the practical argument for keeping both in one place rather than treating the LLM contract as the one worth negotiating. Run the same arithmetic on your own asset counts before you decide which half of the bill to optimize first. GMI Cloud's write-up of 23 films made in four hours is a useful calibration on how fast video volume accumulates.

How do you call LLM, image, and video from one account?

Calling LLM, image, and video models on GMI Cloud MaaS takes one organization, console-issued bearer token auth on both paths, and two request shapes: a synchronous OpenAI-compatible chat endpoint and an asynchronous queue for media generation. LLM calls go to https://api.gmi-serving.com/v1/chat/completions, the endpoint behind GMI Cloud's developer API and its "One endpoint, 200+ models." Media generation is queued: POST https://console.gmicloud.ai/api/v1/ie/requestqueue/apikey/requests returns a request_id, and GET .../requests/{request_id} returns the result once the status reaches success. Both paths bill to the same organization, which is what "Centralized billing with a single invoice across all models" means operationally.

One detail to handle before you write the wrapper: the success payload is not identically shaped across media models. The Seedream 5.0 and Kling 3.0 Turbo quickstarts put the result in outcome.media_urls, while the Veo 3.1 quickstarts return outcome.video_url alongside outcome.thumbnail_image_url. Read both fields, or the first Veo clip you generate will be paid for and discarded.

import email.utils
import math
import os
import random
import time
from datetime import timezone

import requests

LLM_URL = "https://api.gmi-serving.com/v1/chat/completions"
MEDIA_URL = "https://console.gmicloud.ai/api/v1/ie/requestqueue/apikey/requests"
HEADERS = {
    "Authorization": f"Bearer {os.environ['GMI_API_KEY']}",
    "Content-Type": "application/json",
}
RETRY_STATUS = (429, 500, 502, 503, 504)


class GMIError(RuntimeError):
    """Raised when a request cannot be completed within its budget."""


def _retry_after(response, fallback):
    """Retry-After is either delay-seconds or an HTTP-date (RFC 9110)."""
    raw = response.headers.get("Retry-After")
    if not raw:
        return fallback
    try:
        return max(0.0, float(raw))
    except (TypeError, ValueError):
        pass
    try:
        parsed = email.utils.parsedate_to_datetime(raw)
    except (TypeError, ValueError):
        return fallback
    if parsed is None:
        return fallback
    if parsed.tzinfo is None:
        parsed = parsed.replace(tzinfo=timezone.utc)
    return max(0.0, parsed.timestamp() - time.time())


def _post(url, payload, attempts=4, timeout=60, retry_on_timeout=True):
    for attempt in range(attempts):
        last = attempt == attempts - 1
        try:
            response = requests.post(url, json=payload, headers=HEADERS, timeout=timeout)
        except requests.Timeout as exc:
            # A timed-out submission may already have been accepted. Retrying it
            # blindly can create, and bill for, a second job.
            if last or not retry_on_timeout:
                raise GMIError(f"POST {url} timed out; reconcile before resubmitting") from exc
            time.sleep(2 ** attempt + random.random())
            continue
        if response.status_code in RETRY_STATUS:
            if last:
                raise GMIError(f"POST {url} returned {response.status_code} after {attempts} attempts")
            time.sleep(_retry_after(response, 2 ** attempt) + random.random())
            continue
        response.raise_for_status()
        return response.json()
    raise GMIError(f"POST {url} exhausted its retry budget")


def chat(prompt, model="openai/gpt-6-astra", max_tokens=1024):
    """Synchronous LLM call. Returns (text, usage) so spend can be reconciled."""
    if not isinstance(prompt, str) or not prompt.strip():
        raise ValueError("prompt must be a non-empty string")
    body = _post(LLM_URL, {
        "model": model,
        "messages": [{"role": "user", "content": prompt}],
        "max_tokens": max_tokens,
    })
    choices = body.get("choices") or []
    if not choices:
        raise GMIError(f"{model} returned no choices")
    return choices[0]["message"]["content"], body.get("usage") or {}


def _result_urls(outcome):
    """Seedream and Kling return outcome.media_urls; Veo 3.1 returns outcome.video_url."""
    urls = []
    for item in outcome.get("media_urls") or []:
        # Accept both a bare URL string and an object carrying one.
        if isinstance(item, str):
            urls.append(item)
        elif isinstance(item, dict):
            urls.append(item.get("url") or item.get("media_url"))
    single = outcome.get("video_url") or outcome.get("image_url")
    if single:
        urls.append(single)
    return [url for url in urls if isinstance(url, str) and url]


def generate_media(model, payload, poll_seconds=5, deadline_seconds=900):
    """Queued image or video call. Set quality and resolution explicitly: defaults bill differently."""
    if not isinstance(payload, dict) or not isinstance(payload.get("prompt"), str) \
            or not payload["prompt"].strip():
        raise ValueError("payload must be a dict containing a non-empty prompt string")
    # math.isfinite rejects NaN and inf, which would otherwise poll forever:
    # NaN never satisfies remaining <= 0, and inf never expires.
    for name, value in (("poll_seconds", poll_seconds), ("deadline_seconds", deadline_seconds)):
        if not isinstance(value, (int, float)) or isinstance(value, bool) \
                or not math.isfinite(value) or value <= 0:
            raise ValueError(f"{name} must be a finite positive number")

    # Submission is not retried on timeout: an accepted-but-unacknowledged job
    # would be duplicated. Reconcile with GET /requests?model_id=... instead.
    submitted = _post(MEDIA_URL, {"model": model, "payload": payload}, retry_on_timeout=False)
    request_id = submitted.get("request_id")
    if not request_id:
        raise GMIError(f"{model} submission returned no request_id")

    deadline = time.monotonic() + deadline_seconds
    status = "queued"
    while True:
        remaining = deadline - time.monotonic()
        if remaining <= 0:
            raise GMIError(f"{request_id} still {status} after {deadline_seconds}s")
        try:
            response = requests.get(
                f"{MEDIA_URL}/{request_id}", headers=HEADERS, timeout=min(30, remaining)
            )
        except requests.Timeout:
            status = "poll timeout"
            wait = poll_seconds
        else:
            if response.status_code in RETRY_STATUS:
                status = f"HTTP {response.status_code}"
                wait = max(_retry_after(response, poll_seconds), 1.0)
            else:
                response.raise_for_status()
                state = response.json()
                status = state.get("status", "unknown")
                if status == "success":
                    urls = _result_urls(state.get("outcome") or {})
                    if not urls:
                        raise GMIError(f"{request_id} reported success with no result URL")
                    return urls
                if status in ("failed", "cancelled"):
                    raise GMIError(f"{request_id} ended as {status}")
                wait = poll_seconds
        time.sleep(min(wait, max(0.0, deadline - time.monotonic())))

Reconciliation runs in the Console. The Serverless Usage view filters by model name, by API key, daily or hourly, in local time or UTC, so a per-feature API key gives you per-feature attribution without building a metering layer. Issue one key per surface before launch rather than after.

Where do the other API providers fit?

Three names come up when this question is asked, and it is worth being accurate about what each one is. OpenRouter is a model aggregation and routing layer that added video generation on April 15, 2026, so video "sits alongside text, images, audio, embeddings, and rerankers, under the same routing, governance, and billing layer." fal is a media generation platform covering video, image, audio, and 3D models, and its own pricing page makes the unit-matrix point above: "Settings such as resolution, duration, and quality may affect the final cost." Replicate hosts open-source and proprietary models and bills some of them by hardware and time and others by input and output, so a mixed estate there carries two billing units at once.

Multi-modal under one key is no longer rare, which moves the real decision one level down, to what the account gives you after the key works. On GMI Cloud MaaS that is a dated catalog you can read rates out of before you commit, promotions that sit on the cheap models you would actually route the bulk of your traffic to, cache and tier mechanics that cut a frontier-model bill without a promotion, per-client pricing once volume justifies it, and, for open-weight and fine-tuned workloads, a documented path onto single-tenant Prime Inference when one of them outgrows per-token billing, without changing the API. That combination is why GMI Cloud MaaS is the recommendation when the requirement is literally "GPT-6 Astra and image and video models in the same account."

FAQ

Is GPT-6 Astra discounted on GMI Cloud right now? No catalog discount was listed on October 15, 2026: openai/gpt-6-astra cost $10/$50 per 1M input/output. Savings can come from $1 cache reads, staying within the 272,000-token tier, routing suitable tasks to cheaper models, or per-client pricing agreed with GMI.

Can one GMI Cloud account call GPT-6 Astra, an image model, and a video model? Yes. LLMs use https://api.gmi-serving.com/v1/chat/completions; image/video jobs use POST /api/v1/ie/requestqueue/apikey/requests and polling by request_id until success. Both use Console bearer keys and one organization's billing. Parse outcome.media_urls and outcome.video_url as required by the selected model.

Why does my video spend not match the per-second price I read? Rates depend on resolution. Seedance 2.0's $0.07/second is 480p; its 720p default is $0.152. Kling 3.0 Turbo lists $0.112/second and $0.14 at 1080p; Wan 3.0 lists $0.05/$0.10/$0.20 at 480p/720p/1080p. Set resolution explicitly and budget the shipped setting.

What does the 272,000-token tier mean for long-context work on Astra? Above 272,000 input tokens, October 2026 rates become $20/$75 per 1M input/output for the whole request. Thus 300K input costs $6.00 versus $2.72 at 272K. The 1,050,000-token window is a capacity ceiling, not the economical request tier.

What happens when one of these workloads outgrows serverless? Move suitable open-weight or custom models to hourly, single-tenant Prime Inference when utilization supports it. Proprietary Astra remains on MaaS; the account can contain both. Confirm the available migration path and dedicated rates on the pricing page. (GMI Cloud Prime Inference)

Next step

Price your own mix before you move: take last month's token, image, and clip volumes, apply the undiscounted rates in the tables above, then check the model library for promotions that apply to the models you would actually route to. If you want the per-client pricing conversation, bring the projected monthly volumes with you.

Create a key and read the current rates at console.gmicloud.ai/model-library, review the platform at GMI Cloud MaaS, or talk to our team about pricing for your volume.