DEV Community: AIHubMix

DeepSeek V4 Pro (0813) Across 3 APIs: Thinking Passback, Tool Calls, and Hidden 400s

AIHubMix — Fri, 14 Aug 2026 11:58:00 +0000

DeepSeek V4 Pro (0813) is available on AIHubMix through three protocol surfaces:

OpenAI-compatible Chat Completions
OpenAI Responses
Claude-compatible Messages

They reach the same model, but the request and response shapes are not interchangeable. The largest production trap is thinking history: on tool-using multi-turn conversations, dropping the previous turn's thinking content causes a hard HTTP 400.

The findings below come from calls made on August 13, 2026 against the AIHubMix production APIs. The full hands-on guide includes complete examples, observed responses, and the full capability matrix.

The short version

Capability	Chat Completions	Responses	Messages
Endpoint	`/v1/chat/completions`	`/v1/responses`	`/v1/messages`
Thinking off	`thinking.type="disabled"`	`reasoning.effort="none"`	`thinking.type="disabled"`
Thinking passback	`reasoning_content`	`type="reasoning"` item	`thinking` block
Tool schema	nested `function`	flat definition	`input_schema`
Structured output	`response_format`	`text.format`	no native field
Web search	no	`web_search`	`web_search_20250305`

The model has a 1M-token context window, accepts text input, and thinks by default. Sending an excessive max_tokens value is rejected instead of silently truncated; a request with max_tokens=9999999 returned 400 and identified the ceiling as 393,216.

One subtle input warning: Responses does not reject image parts. Unsupported image and file inputs are replaced with placeholder text. "No error" does not mean the model saw the image.

1. Preserve thinking history verbatim

In thinking mode, the previous turn's thinking is part of the conversation state. This matters most in agent loops where the model emits a tool call and the client sends the tool result back.

Chat Completions

Preserve reasoning_content on the historical assistant message:

messages = [
    {"role": "user", "content": "What is 1 + 1? Remember the result."},
    {
        "role": "assistant",
        "content": "2",
        "reasoning_content": "<reasoning_content from the previous response>",
    },
    {"role": "user", "content": "Add 1 to the result."},
]

Dropping reasoning_content returned HTTP 400. Restoring it made the same request continue normally.

Responses

Append the prior response.output without filtering its items:

input = previous_input + response.output + [
    {"role": "user", "content": "Add 1 to the result."}
]

A common framework pattern is to retain only items where type == "message". That silently removes the reasoning item and triggers the next-turn 400.

Messages

Pass the previous response.content back as the assistant message:

messages = [
    {"role": "user", "content": "What's the weather in Paris?"},
    {"role": "assistant", "content": response.content},
    {"role": "user", "content": [tool_result_block]},
]

Keep both the thinking and tool_use blocks. Removing the thinking block returned an invalid_request_error.

2. Turning thinking off requires different fields

Thinking is enabled by default. The off switch depends on the protocol:

# Chat Completions
extra_body={"thinking": {"type": "disabled"}}

# Responses
reasoning={"effort": "none"}

# Messages
extra_body={"thinking": {"type": "disabled"}}

The result is observable. Chat and Messages stop returning their thinking fields. Responses reports zero reasoning tokens and omits the reasoning output item.

low, high, and max were accepted, but token counts for the same prompts did not vary monotonically and the selected level was not echoed. The only level whose effect was unambiguous from the caller side was Responses none.

3. Tool schemas are protocol-specific

Chat Completions wraps a function definition inside function:

tools=[{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get weather for a city",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]

Responses uses a flat definition:

tools=[{
    "type": "function",
    "name": "get_weather",
    "description": "Get weather for a city",
    "parameters": {
        "type": "object",
        "properties": {"city": {"type": "string"}},
        "required": ["city"],
    },
}]

Messages uses input_schema.

There are two more gotchas:

tool_choice: "required" returns 400 on Chat and Responses while thinking is enabled. Use a named-function choice, or disable thinking before using required.
Parallel tool calling cannot be disabled. DeepSeek documents the relevant switches as ignored on Responses and Messages. Serialize calls in your client if ordering matters.

Tool definitions also consume context in full. A request containing 200 definitions succeeded in testing, but the prompt reached 6,105 tokens. Route only the tools relevant to the current task.

4. Structured output, caching, and web search

Chat Completions supports JSON mode through response_format. Responses supports strict JSON Schema through text.format:

response = client.responses.create(
    model="deepseek-v4-pro-0813",
    input="Return the number 1 under key a.",
    text={
        "format": {
            "type": "json_schema",
            "name": "extract",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {"a": {"type": "integer"}},
                "required": ["a"],
            },
        }
    },
)

Messages has no equivalent structured-output field. Carrying a schema in a forced tool is possible, but use Chat or Responses when hard schema guarantees are central.

Context caching is automatic. Repeated long prefixes produced cache hits under different usage fields:

Chat: prompt_tokens_details.cached_tokens
Responses: input_tokens_details.cached_tokens
Messages: cache_read_input_tokens

Put stable system instructions, knowledge snippets, and tool definitions at the front of the request.

Server-side web search worked on Responses and Messages. Chat accepted unknown search-like fields without error, but did not perform retrieval. Route search workloads to Responses or Messages.

Production checklist

Persist thinking content as normal conversation state.
Do not filter Responses output down to message items before passback.
Avoid tool_choice: "required" while thinking is enabled.
Keep the three tool-definition schemas separate.
Do not infer image support from the absence of an error.
Serialize parallel tool calls on the client when required.
Branch on HTTP status, not only error.type, for Responses errors.
Do not use the echoed model field as the sole routing or attribution signal.

DeepSeek V4 Pro's multi-protocol support is useful, but compatibility is a client-side responsibility. Treat thinking as durable conversation state and isolate protocol adapters around history, tools, usage, and errors.

For the complete 3-API matrix, additional code samples, logprobs behavior, current-path deviations, and FAQs, read the full AIHubMix guide. Current pricing and status are on the model page.

Nemotron 3.5 Lightning Is Now Free on AIHubMix

AIHubMix — Tue, 11 Aug 2026 14:15:37 +0000

NVIDIA Nemotron 3.5 Lightning is now available to use for free on AIHubMix.

Try Nemotron 3.5 Lightning on AIHubMix

Built for the execution layer of AI agents

Long-running agents spend much of their time on frequent operational work: calling tools, validating outputs, writing and reviewing code, formatting results, and delegating tasks to sub-agents. Using a large frontier model for every one of those steps can add unnecessary latency and cost.

Nemotron 3.5 Lightning is designed for this execution layer. It is an open 30B Mixture-of-Experts model with only 3B active parameters, combining the capacity of a larger model with a much smaller active compute footprint.

Key capabilities include:

30B total parameters with 3B active parameters
Context windows of up to 1 million tokens
Tool calling and tool-output validation
Coding and specialized task execution
Long-running autonomous-agent workflows
Fast, high-volume inference
Local deployment on supported NVIDIA hardware

Lightning for execution, larger models for planning

Nemotron 3.5 Lightning is the smallest member of the Nemotron 3 family. While larger models such as Nemotron 3 Super and Ultra are suited to advanced reasoning, orchestration, and complex planning, Lightning focuses on the high-frequency execution steps that dominate an agent's workload.

That makes it a practical workhorse for sub-agents, coding assistants, tool-driven workflows, and always-on agent systems.

Start using it for free

The free route is currently available on AIHubMix with zero input and output token pricing:

Model ID: nemotron-3.5-lightning-free
Input: $0 / 1M tokens
Output: $0 / 1M tokens
Context: up to 1M tokens

It works through AIHubMix's OpenAI-compatible API:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["AIHUBMIX_API_KEY"],
    base_url="https://aihubmix.com/v1",
)

response = client.chat.completions.create(
    model="nemotron-3.5-lightning-free",
    messages=[
        {"role": "user", "content": "Help me validate this tool output."}
    ],
)

print(response.choices[0].message.content)

Explore Nemotron 3.5 Lightning and start building on AIHubMix

Seedance 2.5 vs MiniMax H3 vs Wan 3.0: An API-First Comparison

AIHubMix — Sat, 08 Aug 2026 14:49:37 +0000

Choosing an AI video model from demo clips is a poor engineering decision. A production team needs to know which inputs the model accepts, how long it can maintain continuity, how billing works, and how many attempts are required before an output becomes usable.

Seedance 2.5, MiniMax H3, and Wan 3.0 are now all available on AIHubMix. That makes it possible to evaluate the three models behind one API key and a common asynchronous task workflow.

This article compares confirmed product capabilities and proposes a repeatable test plan. It does not claim a universal visual-quality winner because no common public blind benchmark covers all three models.

Model matrix

Capability	Wan 3.0	MiniMax H3	Seedance 2.5
Provider	Alibaba Tongyi Lab	MiniMax	ByteDance Seed
AIHubMix model ID	`wan3.0-video`	`minimax-h3`	`doubao-seedance-2-5-260628`
Maximum single generation	30 seconds	15 seconds	30 seconds
Confirmed resolution	480p, 720p, 1080p on AIHubMix	Up to 2K	Not specified in the official launch post
Audio	Audio references and sound-aware video workflow	Native stereo generation	Joint audio-video generation
References	Text, image, audio, video, documents, and webpages	Text, image, video, and audio	Up to 30 images, 10 videos, and 10 audio clips
Editing focus	Unified reference, editing, replication, and motion driving	Multimodal editing and V2V motion transfer	Timestamp, green-screen, perspective, and reference editing
Best initial fit	Flexible production and ecommerce	Short 2K commercial clips with sound	Multi-shot narrative and targeted edits

One specification deserves caution: third-party pages frequently describe Seedance 2.5 as a 4K model, but ByteDance Seed's July 31 launch post does not state an output resolution. Treat resolution as platform-specific until the active API documentation confirms it.

Model 1: Wan 3.0

Wan 3.0 is the flexible production option. It supports a single generation of up to 30 seconds, and AIHubMix exposes 480p, 720p, and 1080p output tiers.

The broader Wan 3.0 workflow supports text, image, audio, and video references as well as structured sources such as documents, spreadsheets, presentations, PDFs, and webpages. This is useful when a generation needs to stay grounded in product documentation or an existing brand page.

Start with Wan 3.0 for:

ecommerce and product videos;
character animation centered on one stable subject;
continuous 10-to-30-second shots;
workflows that iterate at 480p before rendering at 1080p.

The primary failure mode to test is long-horizon continuity. A 30-second prompt should describe a temporal sequence, camera path, and explicit continuity constraints.

Model 2: MiniMax H3

MiniMax H3 generates up to 15 seconds of native 2K video with stereo audio. MiniMax highlights instruction following, accurate text and brand rendering, reference-based editing, and video-to-video motion transfer.

Start with H3 for:

product ads containing logos or small text;
sound-led short-form video;
2K product or interface shots;
transferring motion or camera language from a source video.

Its engineering tradeoff is duration. For longer narratives, treat each H3 generation as a shot and assemble the sequence in an external editor.

Model 3: Seedance 2.5

Seedance 2.5 generates up to 30 seconds of synchronized audio and video and supports multi-round extension. Its official launch material focuses on story structure, transitions, multimodal references, and post-generation control.

A single request can use up to 30 images, 10 video clips, and 10 audio clips. The model also supports timestamp-level instructions and targeted edits to characters, actions, camera perspective, and green-screen backgrounds.

Start with Seedance 2.5 for:

multi-shot 30-second narratives;
projects with multiple characters and locations;
audiovisual work with several references;
workflows where a local edit is cheaper than regenerating the entire clip.

Reference count is not the same as control. Every asset should have one defined purpose, such as character identity, location, camera movement, or voice.

Calling the models through AIHubMix

The three current model IDs are:

wan3.0-video
minimax-h3
doubao-seedance-2-5-260628

AIHubMix documents an asynchronous video workflow. Enable Async Tasks for the account before submitting jobs.

curl -X POST https://aihubmix.com/ai/v1/videos \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan3.0-video",
    "prompt": "A controlled product shot with one slow camera orbit",
    "resolution": "720p"
  }'

Save the returned task ID, poll the task endpoint, and download the completed artifact.

curl https://aihubmix.com/ai/v1/tasks/{task_id} \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY"

curl https://aihubmix.com/ai/v1/tasks/{task_id}/content \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  --output result.mp4

Model-specific parameters may differ. Switching the model value is useful for an initial harness, but validate supported duration, resolution, and reference fields on each live model page before treating the request schema as identical.

Current AIHubMix billing

Prices checked on August 8, 2026:

Model tier	Price	Ten-second reference cost
Wan 3.0 480p	$0.0338/second	$0.3380
Wan 3.0 720p	$0.06768/second	$0.6768
Wan 3.0 1080p	$0.1352/second	$1.3520
MiniMax H3 768p	$0.07744/second	$0.7744
MiniMax H3 2K	$0.12397/second	$1.2397
Seedance 2.5 without video input	$10.85/million tokens	Usage-dependent
Seedance 2.5 with video input	$6.51/million tokens	Usage-dependent

The two Seedance rates are alternative billing paths, not additive charges. The displayed video-input rate being lower is counterintuitive, and the launch-day model page contains some ambiguity between its input-modality labels and video-reference pricing. Confirm the actual metered usage with a small job before estimating production volume.

Do not compare Seedance's per-token number directly with the per-second prices. Normalize after collecting actual task usage.

A repeatable evaluation harness

Use the same three briefs for every model.

Test A: character continuity

Provide one character reference. Require a turn, a hand interaction, and a camera move. Score face identity, wardrobe, hands, motion, and voice over time.

Test B: product fidelity

Provide one product reference. Require a close-up and an orbit. Score silhouette, logo, small text, materials, reflections, and unwanted redesign.

Test C: temporal instruction following

Define three actions and two camera transitions with explicit timing. Score event order, transition quality, subject continuity, and audiovisual sync.

Persist these fields for every task:

{
  "model": "minimax-h3",
  "brief_id": "product-orbit-v1",
  "attempt": 1,
  "duration_seconds": 10,
  "resolution": "2k",
  "latency_seconds": 0,
  "billed_cost_usd": 0,
  "usable": false,
  "repair_minutes": 0,
  "failure_labels": []
}

The key metric is not price per generation. It is:

cost per usable result = total generation cost / number of accepted outputs

Track manual repair time separately. A cheap model that needs repeated generations and post-production can be more expensive than a model with a higher listed rate.

Decision rules

Pick Wan 3.0 when duration, resolution-based cost control, and broad source grounding are the main requirements.
Pick MiniMax H3 when the deliverable is a short 2K commercial shot with native sound, text, or brand details.
Pick Seedance 2.5 when narrative structure, many references, continuation, and targeted editing matter more than a simple request schema.

Since all three models are now on AIHubMix, the safest selection process is an API-level A/B test using the same brief, acceptance criteria, and cost accounting.

References

Capabilities and prices were checked on August 8, 2026. Verify live documentation before production use.

Wan AI 3.0 API Tutorial: Use Alibaba Wan 3.0 on AIHubMix

AIHubMix — Thu, 06 Aug 2026 14:17:00 +0000

Alibaba's Wan AI has moved from teasers to a public beta. Wan 3.0 can generate videos up to 30 seconds in a single run, render more expressive characters, and use references from multiple input types. Better still, developers can already call the model through AIHubMix instead of waiting for a separate Wan API rollout.

This tutorial shows how to generate a Wan 3.0 video with the AIHubMix API, poll the asynchronous job, download the result, estimate the cost, and write prompts that take advantage of the model's longer shot length.

Launch status: Alibaba announced the Wan 3.0 public beta on August 6, 2026. AIHubMix lists the model as wan3.0-video. Features and prices in this guide reflect the launch-day API and may change during the beta.

What Is Wan AI 3.0?

Wan AI is Alibaba's video generation model family. The Wan 3.0 public beta focuses on three improvements:

Native 30-second generation: one request can produce a video up to 30 seconds long.
Reality-grade rendering: Alibaba highlights more expressive characters, stronger reference consistency, and better rendering of digital content.
Omni-Reference: Wan 3.0 can reason over text, images, audio, video, and structured sources such as documents, spreadsheets, slides, PDFs, and webpages.

Alibaba describes these features in the official Wan 3.0 launch thread. The AIHubMix launch announcement confirms that Wan 3.0 is live on its platform with text, image, audio, and video inputs.

Wan 3.0 on AIHubMix at a glance

Item	Value
Model ID	`wan3.0-video`
Endpoint	`https://aihubmix.com/ai/v1/videos`
Maximum duration	Up to 30 seconds
Resolutions	480p, 720p, 1080p
Inputs listed by AIHubMix	Text, image, audio, video
Output	Video
Job type	Asynchronous

The wider Wan 3.0 beta also advertises document and webpage references. At launch, however, the AIHubMix model page explicitly lists text, vision, audio, and video modalities. Check the current documentation before sending document-native inputs through the gateway.

Why Use Alibaba Wan Through AIHubMix?

AIHubMix provides a single API key and a consistent developer workflow across many AI models. For Wan 3.0, the practical advantages are immediate access, an asynchronous task endpoint, and launch pricing below Alibaba's published public-beta rates.

The AIHubMix Wan 3.0 model page currently lists:

IHubMix price
480p:price per second $ 0.04225;
720p: price per second $0.0846;
1080p: price per second $0.169.

Alibaba's launch thread lists $0.05, $0.10, and $0.20 per second for the same resolutions. That makes the launch-day AIHubMix rates about 15.5% lower. Always verify the live model page before estimating production costs.

Prerequisites

You need:

An AIHubMix account and API key.
The Async Tasks feature enabled for your account in the AIHubMix console.
curl for the REST example, or Python 3.9+ for the SDK example.

Store the key in an environment variable instead of placing it in source code:

export AIHUBMIX_API_KEY="your_api_key_here"

Do not commit .env files or API keys to Git.

Generate a Wan 3.0 Video With cURL

Wan 3.0 generation is asynchronous. The workflow has three steps:

Submit a video job.
Poll the returned task ID until the job completes.
Download the generated MP4.

Step 1: Submit the video job

curl -X POST https://aihubmix.com/ai/v1/videos \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan3.0-video",
    "prompt": "A continuous cinematic tracking shot follows a cyclist through a rain-soaked Tokyo side street at night. Neon signs reflect in the pavement. The camera begins wide, moves alongside the cyclist, then slowly pushes in as steam rises from a food stall. Natural motion, realistic skin and fabric, physically accurate reflections, no cuts.",
    "seconds": "10",
    "size": "720p"
  }'

The response contains a task identifier. Save it as task_id for the next request.

Step 2: Poll the task status

curl https://aihubmix.com/ai/v1/tasks/{task_id} \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY"

Poll at a reasonable interval, such as every 10 to 15 seconds. Stop when the status becomes completed, failed, or canceled. Aggressive polling does not make generation faster and may trigger rate limits.

Step 3: Download the video

curl https://aihubmix.com/ai/v1/tasks/{task_id}/content \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  --output wan3-result.mp4

Open wan3-result.mp4 locally and review subject consistency, camera motion, unwanted cuts, and visual artifacts before using it in a production workflow.

Use Wan 3.0 With Python

AIHubMix also documents an OpenAI-compatible Python workflow. Install or update the SDK:

pip install -U openai

Create generate_wan_video.py:

import os
import sys
import time

from openai import OpenAI


API_KEY = os.environ.get("AIHUBMIX_API_KEY")
if not API_KEY:
    sys.exit("Set AIHUBMIX_API_KEY before running this script.")

client = OpenAI(
    api_key=API_KEY,
    base_url="https://aihubmix.com/v1",
)

prompt = (
    "A single uninterrupted product shot of a silver smartwatch on black "
    "volcanic stone. Soft morning light moves across the brushed metal. "
    "The camera makes a slow 180-degree orbit while condensation gathers "
    "on the surface. Premium commercial realism, restrained reflections, "
    "stable logo placement, no text overlays, no cuts."
)

video = client.videos.create(
    model="wan3.0-video",
    prompt=prompt,
    seconds="10",
    size="720p",
)

print(f"Created task: {video.id}")

while video.status in ("queued", "in_progress"):
    progress = getattr(video, "progress", 0) or 0
    print(f"Status: {video.status}; progress: {progress}%")
    time.sleep(10)
    video = client.videos.retrieve(video.id)

if video.status != "completed":
    error = getattr(getattr(video, "error", None), "message", "Unknown error")
    sys.exit(f"Generation ended with status {video.status}: {error}")

content = client.videos.download_content(video.id)
content.write_to_file("wan3-result.mp4")
print("Saved wan3-result.mp4")

Run it:

python generate_wan_video.py

For a production service, move polling into a background worker, add exponential backoff, persist the task ID, and make downloads resumable. A web request should not remain open while a 30-second AI video is rendering.

How to Write Better Wan AI Prompts

A good Wan 3.0 prompt reads like a compact shot brief, not a list of style adjectives. Use this order:

Subject + action + setting + lighting + camera movement + shot progression + continuity constraints

1. Describe movement over time

A 30-second clip needs progression. Explain how the action and camera evolve from the opening to the final frame.

Weak:

A cinematic woman in a futuristic city.

Better:

A courier walks through a crowded futuristic market at dawn. Begin with a wide establishing shot, track backward at walking speed as she approaches, then arc to her left when she stops at a glowing map kiosk. Steam crosses the foreground while the crowd continues moving naturally. One continuous take, no cuts.

2. Name a specific camera move

Replace vague words such as "cinematic" with a physical direction:

slow push-in
lateral tracking shot
handheld follow shot
crane down to eye level
180-degree product orbit
locked-off wide shot

Use one main move and one transition. Too many camera instructions often create unstable motion.

3. Protect identity and product details

When using a reference image or video, explain its role:

Use the first reference for the character's face, hair, and clothing. Use the second reference for the cafe interior and color palette. Preserve the same character identity, jacket details, and table layout throughout the shot.

Do not assume the model knows which reference controls the person, location, or product.

4. Use constraints sparingly

Add only constraints that can be checked in the final video:

One continuous take, no scene cuts, stable facial identity, natural hand motion, no text overlays.

Long negative-prompt lists can compete with the main direction. Start with four or five important constraints, generate a short test, and refine from the visible failure.

Three Wan 3.0 Prompt Examples

Cinematic character scene

A tired detective enters a quiet all-night diner during heavy rain. The camera starts outside the window, slowly pushes through the doorway behind him, and follows as he removes his wet coat and sits at the counter. Fluorescent light mixes with red neon from the street. Keep his face, charcoal coat, and age consistent throughout. Subtle natural expression, realistic wet fabric, one continuous take, no cuts.

Ecommerce product video

A white running shoe rests on a wet track before sunrise. Begin with an extreme close-up of water droplets on the mesh, pull back into a low three-quarter view, then make a smooth half-orbit as warm sunlight reaches the sole. Preserve the shoe silhouette, material, color, and logo placement. Premium commercial lighting, physically accurate reflections, no extra text, no cuts.

Social media food clip

A chef plates handmade ramen in a compact open kitchen. Start overhead as noodles enter the bowl, descend to counter height when broth is poured, then track sideways as the chef adds egg and scallions. Warm practical lighting, visible steam, natural hand movement, appetizing realistic texture. One continuous 10-second take, no text overlay.

A Cost-Smart Testing Workflow

Do not begin prompt development with a 30-second 1080p render. Use a staged workflow:

Test composition and motion at 480p for 5 seconds.
Fix identity, hand, camera, and continuity problems.
Validate the final prompt at 720p for 10 seconds.
Render the 30-second 1080p version only after the shot is stable.

At current AIHubMix pricing, a 5-second 480p test costs about $0.21, while a 30-second 1080p render costs $5.07. Iterating at the lowest useful setting can reduce prompt-development cost substantially.

Common API Problems

The request returns an authorization error

Confirm that AIHUBMIX_API_KEY is set in the same shell that runs the command. Also check that the header uses Bearer followed by a space and the key.

The asynchronous endpoint is unavailable

Enable Async Tasks for the account in the AIHubMix console. The video endpoint depends on that account-level feature.

The task stays queued

Longer and higher-resolution videos need more processing time, especially during a public-beta launch. Keep the task ID, poll less frequently, and retry status requests rather than submitting duplicate paid jobs.

The Python client has no `videos` attribute

Update the openai package. Video methods require a recent SDK version:

pip install -U openai

If your environment must stay on an older SDK, use the REST workflow shown earlier.

A long video loses consistency

Reduce competing actions, specify one camera path, state which reference controls each element, and test a shorter version first. A 30-second generation magnifies ambiguity in the prompt.

Wan 3.0 FAQ

Is Wan 3.0 available now?

Yes. Alibaba announced Wan 3.0 as a public beta on August 6, 2026, and AIHubMix made wan3.0-video available the same day.

Is Wan 3.0 an Alibaba model?

Yes. Wan AI is developed by Alibaba's Tongyi Lab. Search terms such as Wan Alibaba, Alibaba Wan, and Wan AI refer to the same model family.

Can Wan 3.0 generate a 30-second video?

Yes. The public beta supports native video generation up to 30 seconds in a single run.

Does AIHubMix support image-to-video with Wan 3.0?

The AIHubMix model page lists vision, audio, and video alongside text as supported input modalities. The launch-day quick start demonstrates text-to-video. Check the latest API documentation for the current upload and reference schema before building a multimodal production pipeline.

How much does the Wan 3.0 API cost?

At publication time, AIHubMix lists $0.04225 per second for 480p, $0.0846 for 720p, and $0.169 for 1080p. A 30-second clip therefore costs approximately $1.27, $2.54, or $5.07, depending on resolution.

Start Building With Wan 3.0

Wan 3.0 changes the useful unit of AI video generation from a short visual beat to a complete 30-second shot. The best way to evaluate it is to start with a tightly directed 5-second test, refine the motion and continuity, and scale only the prompts that hold together.

Use the wan3.0-video model page on AIHubMix to verify current pricing and API availability, then submit your first asynchronous generation with the examples above.

Sources: Alibaba Wan 3.0 public-beta announcement, AIHubMix Wan 3.0 announcement, and AIHubMix Wan 3.0 model details.
``

DeepSeek V4 Flash Was Degraded Today. Here’s Why Multi-Provider Failover Matters

AIHubMix — Tue, 04 Aug 2026 11:36:05 +0000

On August 4, 2026, DeepSeek’s official status page recorded two API degraded-performance incidents.

The first incident lasted 1 hour and 18 minutes, from 02:02 to 03:20 UTC, and affected DeepSeek V4 Flash, V4 Pro, and Expert Mode. The second incident lasted 36 minutes, from 03:43 to 04:20 UTC, and affected the DeepSeek V4 Flash API.

Both incidents have since been resolved. OpenCode also reported that DeepSeek Flash was experiencing capacity issues due to unprecedented demand. However, DeepSeek’s official status page only confirmed degraded performance and did not publish a root cause.

TL;DR

DeepSeek’s official status page recorded two degraded-performance incidents affecting V4 Flash on August 4, 2026.
A direct provider integration creates a single point of failure, even when the same model is available elsewhere.
AIHubMix can retry the same model across multiple provider channels when an upstream route returns a retryable error.
If all provider channels for the primary model fail, Key-level model fallback can switch the request to configured backup models.
Multi-provider routing reduces reliance on one endpoint, but it cannot eliminate correlated failures or gateway-level risk.

Incidents like this highlight an important infrastructure principle:

A reliable model is not enough if it is accessed through a single provider endpoint.

One Model Does Not Have to Mean One Provider

When an application connects directly to one provider, that endpoint becomes a single point of failure.

If the provider experiences an outage, reaches its rate limit, or suffers a latency spike, the application has nowhere else to send the request. Users see timeouts and errors even when the same model remains available through other infrastructure providers.

AIHubMix separates the model from the provider serving it.

For example, DeepSeek V4 Flash is available through multiple providers on AIHubMix, including DeepSeek, Baidu, DeepInfra, and Alibaba Cloud. Applications continue using one OpenAI-compatible API endpoint while AIHubMix manages the available upstream routes.

This creates two distinct reliability layers.

Layer 1: Provider Failover

Provider failover keeps the requested model unchanged while switching the infrastructure provider behind it.

When a request for DeepSeek V4 Flash reaches AIHubMix, the gateway selects an eligible provider channel. If that channel returns a retryable error before the response begins, AIHubMix can try another available channel for the same model.

The request path may look like this:

Try DeepSeek V4 Flash through Provider A.
Provider A returns a timeout, 5xx error, or retryable capacity error.
Try the same DeepSeek V4 Flash model through Provider B.
Continue until the request succeeds or all eligible channels are exhausted.

The client does not need to integrate multiple provider SDKs, manage separate API keys, or implement its own retry logic.

This is provider-level failover: the provider changes, but the requested model stays the same.

Layer 2: Model Fallback

A provider failover cannot help if every available provider for the primary model is unavailable.

AIHubMix therefore supports a second reliability layer: model fallback.

Users can configure an ordered list of backup models for each API key. After every eligible channel for the primary model has returned a retryable failure, AIHubMix moves to the next model in the fallback list.

For example:

Primary: deepseek-v4-flash
First fallback: gpt-5.4
Second fallback: gemini-3.1-pro-preview

The fallback is performed inside the AIHubMix gateway. Existing applications do not need to send additional routing parameters or change their client code.

Billing is based on the model that ultimately returns the successful response. Developers can verify fallback behavior through the response headers:

X-Aihubmix-Fallback: true
X-Aihubmix-Model: <final-model>

The complete configuration and trigger rules are documented in AIHubMix Model Mapping and Fallback.

What Automatic Failover Can Handle

Provider failover is designed to recover from upstream infrastructure problems such as:

Provider timeouts
Connection failures
Retryable 5xx responses
Provider rate limits and capacity errors
Temporary unavailability of an upstream channel

When these failures occur before the response starts, AIHubMix can transparently try another route.

What Failover Cannot Solve

Multi-provider routing improves availability, but it does not make a gateway infallible.

Fallback is not triggered when:

The user’s AIHubMix API key is invalid, expired, or out of quota
The request itself is invalid
The client disconnects or reaches its own timeout
A streaming response has already started
A specific provider channel was explicitly selected
The failure affects every provider or the gateway itself

Provider failures may also be correlated. Multiple providers can depend on the same underlying infrastructure, model release, or regional network. For this reason, multi-provider availability should be measured with real traffic rather than assumed from the number of providers alone.

Why an Aggregator Can Be More Reliable Than a Direct Endpoint

Calling an official API directly gives an application one route to the model.

A multi-provider gateway gives it several.

If those provider routes fail independently, the gateway can route around a degraded endpoint without exposing the failure to the application. This reduces reliance on any single provider and can deliver higher availability than a direct single-provider integration.

The difference is architectural:

Direct API: one model, one provider, one failure domain
AIHubMix: one model, multiple providers, automatic failover
AIHubMix with model fallback: multiple providers plus backup models

The goal is not to predict which provider will fail next. It is to make an upstream incident an internal routing event instead of a customer-facing outage.

Build for the Next Provider Incident

DeepSeek V4 Flash has recovered, but temporary capacity constraints, rate limits, and upstream outages are normal parts of production AI infrastructure.

Applications should not have to change code every time a provider becomes unstable.

With AIHubMix, developers can access multiple providers through one API, automatically retry the same model across available channels, and configure backup models for an additional layer of protection.

Explore available models and providers at aihubmix.com/models.

FAQ

What is multi-provider failover?

It automatically retries the same model through another eligible provider when the current route returns a retryable failure.

How is model fallback different?

Provider failover keeps the model unchanged. Model fallback switches to a configured backup model only after all eligible channels for the primary model fail.

Which failures can trigger failover?

Typical triggers include timeouts, connection failures, retryable 5xx responses, rate limits, and temporary capacity errors before a response begins.

Does failover guarantee zero downtime?

No. Correlated provider failures, gateway-level incidents, non-retryable errors, and failures after streaming begins can still reach the client.

Do I need to change my application code?

No additional routing logic is required. Applications keep using the AIHubMix OpenAI-compatible endpoint, while backup models can be configured at the API-key level.

Using Chinese AI Model APIs Outside China: Payment Options and Token Costs

AIHubMix — Mon, 03 Aug 2026 13:10:34 +0000

This is a price snapshot, not a model benchmark. I compared four Chinese model endpoints available through the same API catalog so that the billing units and date are consistent. The result is less about finding one winner than identifying three distinct workload tiers:

Flagship capability and very long context: Kimi K3.
A middle tier for capability, context, and price: GLM-5.2 during the catalog’s discount window.
Low-cost generation and high-volume processing: DeepSeek V4-Pro and DeepSeek V4-Flash-0731.

All prices below are the USD rates displayed by AIHubMix on August 3, 2026, per one million input or output tokens. These are aggregator rates rather than the model vendors’ direct list prices. Routing, upstream providers, and promotions may change them.

Scope note: AIHubMix is the data source because this article compares what one customer would pay through one catalog. This is not an endorsement of the platform, and the article does not claim that token price predicts model quality. Recheck live prices before making a production budget.

Model	AIHubMix input / output	Cached input	Workload to test
Kimi K3	$3.00 / $15.00	$0.30	1M context, long-horizon coding, and complex knowledge work
GLM-5.2, 30% discounted	$0.79 / $2.76	$0.20	Long-context coding, agents, and overall value
DeepSeek V4-Pro	$0.46 / $0.93	About $0.00385, route-specific	Output-heavy reasoning, coding, and content generation
DeepSeek V4-Flash-0731	$0.099 / $0.198	$0.0198	Classification, extraction, batch jobs, and high concurrency

Note: The DeepSeek V4-Pro summary rounds cached input to $0.00. Its DeepSeek upstream route shows a cache-read price of approximately $0.0038512 per million tokens. Check the route used by your request when reconciling a bill.

For comparison, AIHubMix currently lists Claude Opus 5 at $5 / $25, GPT-5.6 Sol at $5 / $30, GPT-5.6 Terra at $2 / $12, and GPT-5.6 Luna at $0.20 / $1.20.

On output price alone, discounted GLM-5.2 costs about one-ninth as much as Claude Opus 5. DeepSeek V4-Pro is about one twenty-seventh, while DeepSeek V4-Flash-0731 is about one one-hundred-and-twenty-sixth. Those gaps are substantial, but price alone does not capture task success rate, context requirements, output volume, or latency.

How to Pay From Outside China

The token prices are only half the problem. Developers outside mainland China can run into account and payment friction when a provider expects a local phone number, Alipay, or WeChat Pay. There are three practical approaches.

1. Self-Host Open Weights

GLM-5.2 is published on Hugging Face under the MIT license. The weights do not carry an API fee, but inference is not free: GPUs, serving infrastructure, monitoring, upgrades, and engineering time all move onto your side of the ledger. Self-hosting becomes economically interesting only when utilization and control requirements justify that operational cost.

2. Use an Aggregator Available in Your Region

Several model aggregators expose at least some Chinese models and accept payment methods that are easier to use internationally. The trade-off is inconsistent coverage. A service may list one DeepSeek release but not the newest GLM or Kimi endpoint, and model IDs, context limits, caching, and tool support can differ.

3. Use an OpenAI-Compatible Gateway With Card Billing

AIHubMix is one example of this approach. Its console currently offers both Alipay and Credit/Debit Card top-ups, while the API uses an OpenAI-compatible base URL. Card acceptance can still depend on the issuer and region, so verify it before designing a production billing process.

The engineering benefit is modest but useful: one account, one balance, and one SDK integration for the model IDs in this comparison. The trade-off is an additional dependency between your application and the original model provider. Check the gateway’s status history, data policy, route behavior, and effective price rather than treating API compatibility as equivalence.

What These Prices Actually Buy

GLM-5.2: How the Discount Changes the Middle Tier

AIHubMix displays regular GLM-5.2 prices of $1.13 for input, $3.94 for output, and $0.28 for cached input. The current 30% discounted rates are $0.79, $2.76, and $0.20 respectively. The page labels the discount window as 09:00–08:59 GMT+9; individual upstream routes may show different windows, so production budgets should use the live rate.

GLM-5.2 offers a 1M-token context window, up to 128K output, reasoning, tool use, function calling, and structured outputs. The listed output rate stays below $3 per million tokens while the endpoint supports repository-scale code, long documents, and multi-step agent workflows.

If your application repeatedly reads an entire codebase, a large policy document, or a long conversation history, GLM-5.2 is one candidate to include in the default-model evaluation.

DeepSeek V4-Pro: Sub-$1 Output for Heavier Work

AIHubMix lists DeepSeek V4-Pro at $0.46 for input and $0.93 for output. It also provides a 1M-token context window, up to 384K output, reasoning, tools, function calling, and structured outputs.

That price structure is relevant when output is much larger than input: code generation, bulk drafting, long answers, and first-pass reports. V4-Pro can be tested against Flash for tasks that need heavier reasoning and longer generation. Its listed output rate is lower than GLM-5.2's.

DeepSeek V4-Flash-0731: The Volume Tier

DeepSeek V4-Flash-0731 costs $0.099 for input, $0.198 for output, and $0.0198 for cached input on AIHubMix. It is not the obvious choice for the hardest final decision, but it is well suited to large quantities of cheap, standardized work:

Text classification and tagging
Field extraction and format conversion
First-pass search-result filtering
Log summarization and ticket routing
High-volume short-form generation

Sending every request directly to a flagship model means paying a premium for tasks that may not need flagship capability. Flash can be tested at the first layer of a model-routing system.

At 100 million output tokens, the page rates imply approximately $19.80 for DeepSeek V4-Flash-0731, $93 for DeepSeek V4-Pro, $276 for discounted GLM-5.2, $1,500 for Kimi K3, and $2,500 for Claude Opus 5. This excludes caching, failed retries, and tokens consumed around tool calls, but it illustrates why batch work deserves a dedicated low-cost tier.

Kimi K3: The Higher-Cost Long-Context Option

Kimi K3 is the most expensive Chinese model in this comparison: $3 for input, $15 for output, and $0.30 for cached input. AIHubMix shows a 1M context window and up to 1M output, with text, image, and video input. Its positioning is clear: long-horizon coding and end-to-end knowledge work.

What Actually Determines the Bill

1. Price GLM-5.2 Using the Discount Window

GLM-5.2’s regular and discounted output rates are $3.94 and $2.76. At 100 million output tokens, the difference is about $118. At meaningful scale, whether requests hit the discounted route changes the monthly budget. Record the route and effective unit price in monitoring rather than treating a promotional rate as permanent.

2. Caching Only Helps Repeated, Stable Context

Caching becomes valuable when an agent resends the same system prompt, tool definitions, project rules, or reference material on every turn. DeepSeek V4-Flash-0731 lists cached input at $0.0198, discounted GLM-5.2 at $0.20, and Kimi K3 at $0.30. If every prompt is different, low cache prices will not automatically reduce the bill.

3. Output-Heavy Workloads Need Output-First Pricing

Summarization and classification often have large inputs and short outputs. Code generation, long-form writing, and deep reasoning tend to produce more output. Optimize the former around input and cache rates; optimize the latter around output rates. Adding the two headline prices together is rarely a useful ranking method.

4. The Cheapest System Usually Uses More Than One Model

A practical three-layer route looks like this:

Send classification, extraction, and simple batch jobs to DeepSeek V4-Flash-0731.
Use GLM-5.2 or DeepSeek V4-Pro for most production work.
Reserve Kimi K3 or another high-priced frontier model for the small set of high-risk, very long, or unusually difficult tasks.

This routing policy can be implemented in the application based on task type, context length, and retry count. Measure fallback frequency because a cheap first attempt can become expensive when it repeatedly fails.

Calling the Models Through One Gateway

AIHubMix exposes an OpenAI-compatible API. An application already using the OpenAI SDK typically needs only a different base_url, API key, and model ID:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["AIHUBMIX_API_KEY"],
    base_url="https://aihubmix.com/v1",
)

response = client.chat.completions.create(
    model="glm-5.2",
    messages=[
        {
            "role": "user",
            "content": "Review this project's architecture and propose a migration plan.",
        }
    ],
)

print(response.choices[0].message.content)

Change model to deepseek-v4-pro, deepseek-v4-flash-0731, or kimi-k3 to switch models. Test streaming, timeouts, tool calls, and structured outputs separately before production use. API compatibility does not mean every model behaves identically.

A Reasonable Evaluation Setup

For a simple starting configuration:

Default-model candidate: GLM-5.2. Discounted pricing and a 1M context window make it worth testing for code and long tasks.
Output-heavy production model: DeepSeek V4-Pro. Output costs less than $1 per million tokens.
Batch model: DeepSeek V4-Flash-0731. Push low-risk, high-concurrency work to the lowest-cost tier.
Long-horizon candidate: Kimi K3. Test it when 1M context, multimodal input, and unusually long output are genuinely useful.

Do not choose from a few subjective chat responses. Build an evaluation set of 50–200 real tasks and measure success rate, human rework, average input and output tokens, P95 latency, and retry count. “Cost per successful task” is usually more informative than price per million tokens.

FAQ

What Is the Cheapest Model in This Comparison?

DeepSeek V4-Flash-0731 has the lowest input and output rates at $0.099 / $0.198. It is appropriate for batch and standardized tasks. Test DeepSeek V4-Pro, GLM-5.2, or Kimi K3 for complex reasoning and long-horizon coding.

How Much Does GLM-5.2 Cost on AIHubMix?

The page shows regular rates of $1.13 input, $3.94 output, and $0.28 cached input. The current 30% discounted rates are $0.79 input, $2.76 output, and $0.20 cached input, all per million tokens. Discount windows and routes may change.

Why Does the DeepSeek V4-Pro Price Differ From Other Sites?

This article uses the current price of AIHubMix’s aggregated deepseek-v4-pro model ID. AIHubMix exposes several upstream routes at different prices, and its model page says the aggregated ID uses the official discounted channel. Always compare the same model ID and actual route.

Are Chinese Models Always Better Value Than OpenAI or Anthropic Models?

Their token prices are often much lower, but the real metric is cost per completed task. Extra retries, manual corrections, or unnecessarily long output can reduce the apparent savings. Evaluate with your own workload.

Will These Prices Stay the Same?

No. Platforms change promotions, providers, routes, and caching rates. This article is a snapshot from August 3, 2026. Use the live AIHubMix model pricing page for production budgets and customer quotes.

Benchmarking GLM-5.2 Fast: 100 Requests Across Chat, Coding, and Math

AIHubMix — Wed, 22 Jul 2026 15:51:04 +0000

GLM-5.2 Fast is now available through AIHubMix. We benchmarked it against GLM-5.2 using real prompts and a production API endpoint.

TL;DR

Across three 100-request benchmark categories, GLM-5.2 Fast delivered:

83-94% higher per-user throughput
53-77% higher system throughput
41-46% lower inter-token latency
38.5-42.5% lower median end-to-end request latency

Its clearest advantage appears after generation begins: output streams faster and complete responses finish sooner. This makes it especially useful for real-time chat, coding agents, streamed long-form generation, and multi-step agentic workflows.

Benchmark setup

We used three real-prompt datasets representing different workloads:

Category	Dataset
Chat	ShareGPT
Coding	instruct_coder
Math reasoning	AIMO

The benchmark configuration was:

100 requests per category for each model
Identical prompt samples selected with random seed 42
Concurrency: 5
Streaming responses
Server-reported token counts
Production AIHubMix chat completions endpoint
Benchmark runner: aiperf

The models tested were alicloud-glm-5.2 and alicloud-glm-5.2-fast-preview.

Using the same seed ensures both models receive the same sampled prompts. It does not eliminate normal infrastructure variation, but it prevents one model from receiving an easier prompt set.

Result 1: Per-user throughput increased by 83-94%

Per-user throughput is the number of output tokens delivered to one user per second after generation begins. It is the metric most closely related to how fast a streaming response feels.

Workload	GLM-5.2	GLM-5.2 Fast	Improvement
Chat	50.2 tok/s	97.2 tok/s	+94%
Coding	53.3 tok/s	98.1 tok/s	+84%
Math reasoning	61.4 tok/s	112.7 tok/s	+83%

Across the three categories, GLM-5.2 Fast delivered about 1.8-1.9x the per-user throughput of GLM-5.2.

Result 2: System throughput increased by 53-77%

System throughput measures the total number of output tokens generated per second across all concurrent requests. It is useful for understanding aggregate serving capacity under load.

Workload	GLM-5.2	GLM-5.2 Fast	Improvement
Chat	158.6 tok/s	242.5 tok/s	+53%
Coding	245.6 tok/s	416.3 tok/s	+70%
Math reasoning	262.4 tok/s	463.6 tok/s	+77%

These values were measured with concurrency set to 5.

Result 3: Inter-token latency fell by 41-46%

Inter-token latency measures the average delay between consecutive streamed output tokens. Lower values produce a denser, more continuous response stream.

Workload	GLM-5.2	GLM-5.2 Fast	Reduction
Chat	20.58 ms	12.12 ms	-41%
Coding	18.93 ms	10.31 ms	-46%
Math reasoning	16.40 ms	8.93 ms	-46%

This was the most consistent low-level speed signal in the benchmark.

Median end-to-end latency fell by 38.5-42.5%

End-to-end latency measures the complete request duration, from sending the request until the streamed response finishes.

Workload	GLM-5.2	GLM-5.2 Fast	Reduction
Chat	7.68 s	4.73 s	-38.5%
Coding	29.20 s	17.84 s	-38.9%
Math reasoning	33.41 s	19.22 s	-42.5%

These figures are for individual model requests, not complete agent tasks. In a multi-step workflow, however, time saved on sequential model calls can compound across the full task.

What about time to first token?

We measured TTFT, but the P50 results did not move consistently in one direction:

Chat: 1.6% slower
Coding: 2.9% faster
Math reasoning: 6.4% faster

Tail results also varied by workload. We are therefore not making a blanket claim that GLM-5.2 Fast always produces the first token sooner.

The more reliable conclusion is that once generation starts, tokens arrive faster and the complete response finishes sooner.

Best use cases

GLM-5.2 Fast is particularly well suited to:

Real-time AI chat, where faster streaming directly improves perceived responsiveness
Coding agents, where long code and reasoning outputs can dominate task duration
Multi-step agentic workflows, where latency savings accumulate across sequential calls
High-concurrency applications, where system throughput affects aggregate capacity
Streamed long-form generation, where lower inter-token latency creates a more continuous output stream

Production fallback configuration

The GLM-5.2 Fast route is currently provided by Alibaba Cloud only. For production traffic, we recommend:

Primary:  glm-5.2-fast-preview
Fallback: glm-5.2

Key-level fallback can route eligible requests to standard GLM-5.2 if the Fast route is temporarily unavailable. It reduces exposure to a single upstream provider, but it is not a guarantee of uninterrupted service. Production systems should still implement timeouts, retries, monitoring, and error handling.

Pricing and model details

At the time of publication, the model page lists:

Item	Value
Input price	$2.254 per 1M tokens
Output price	$7.889 per 1M tokens
Context length	1M tokens
Fast-route provider	Alibaba Cloud

Pricing and availability may change. Check the model page before deploying.

Benchmark caveats

For the Fast coding run, 100 requests were issued, while 99 responses contained usable server-reported token counts for token-derived metrics.

Results also depend on prompt distribution, output length, concurrency, network conditions, provider load, and test timing. Treat these numbers as evidence from this controlled test, not a guarantee for every request.

Try GLM-5.2 Fast

View current pricing, provider availability, and API details on the GLM-5.2 Fast model page.

For production traffic, enable fallback to GLM-5.2 before routing critical workloads to the Fast route.

Kimi K3 API Guide: Reasoning, Tool Calling, Structured Output, and Vision

AIHubMix — Tue, 21 Jul 2026 11:24:37 +0000

If you are testing Kimi K3 through an OpenAI-compatible API, there are a few details worth knowing before you wire it into production.

Kimi K3 is not just another chat model with a larger context window. It has always-on thinking, a 1M-token context window, API-specific differences across Chat Completions, Responses, and Claude-compatible Messages, plus a few edge cases that can surprise client code.

This guide summarizes what we verified on AIHubMix, including:

reasoning_effort="max" and thinking history
Tool calling and dynamic tool loading
Structured output support
Automatic context caching
Prefix completion
Vision input
Stop sequence behavior

Test note: The behavior below was verified through AIHubMix production APIs on July 17, 2026. Model providers may change behavior over time, so check the latest model page and official docs before relying on edge-case behavior.

Kimi K3 at a glance

Item	Value
Context window	1M tokens
Max output	`max_completion_tokens` defaults to 131,072, up to 1,048,576
Input modalities	Text and images
Thinking mode	On by default
Reasoning setting	`reasoning_effort` only supports `"max"`
Stop sequences	At most 5 entries, each no longer than 32 bytes
APIs on AIHubMix	Chat Completions, Responses, Claude-compatible Messages

If you need deep reasoning, long-context tasks, agent workflows, structured extraction, or code generation with large context, Kimi K3 is the model to test first.

For quick experiments, Kimi K3 Free can be a useful entry point before moving heavier workloads to the full Kimi K3 API.

1. Thinking mode: `reasoning_effort` only supports `max`

Kimi K3 thinking is enabled by default. The important part is that reasoning_effort only supports one value:

from openai import OpenAI

client = OpenAI(
    base_url="https://aihubmix.com/v1",
    api_key="<AIHUBMIX_API_KEY>",
)

completion = client.chat.completions.create(
    model="kimi-k3",
    reasoning_effort="max",
    messages=[
        {
            "role": "user",
            "content": "A snail climbs 3 meters each day and slides 2 meters each night. The well is 10 meters deep. How many days?",
        }
    ],
)

print(completion.choices[0].message.reasoning_content)
print(completion.choices[0].message.content)

For multi-turn conversations, pass the previous assistant message back complete and unmodified, including thinking content.

messages = [
    {"role": "user", "content": "What is the capital of France?"},
    {
        "role": "assistant",
        "content": "Paris.",
        "reasoning_content": "<reasoning_content from the previous response>",
    },
    {"role": "user", "content": "And its population?"},
]

This matters because Kimi K3 is trained with preserved thinking history. If your session manager, proxy, or logging layer strips thinking fields, later turns may become less stable.

2. Sampling parameters are fixed

Kimi K3 uses fixed sampling settings from the provider:

temperature: 1.0
top_p: 0.95
n: 1
presence_penalty: 0
frequency_penalty: 0

The practical recommendation is simple: omit these parameters unless the provider documentation says otherwise.

3. Tool calling and dynamic tool loading

Kimi K3 supports up to 128 tools. Tool calling works across APIs, but the syntax differs.

Chat Completions

tool_choice supports auto, none, and required.

Kimi K3 also supports dynamic tool loading in Chat Completions. You can inject a new tool mid-conversation using a system message that contains tools and no content.

messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Hello."},
    {"role": "assistant", "content": "Hi, how can I help you?"},
    {
        "role": "system",
        "tools": [
            {
                "type": "function",
                "function": {
                    "name": "get_time",
                    "description": "Get the current time",
                    "parameters": {"type": "object", "properties": {}},
                },
            }
        ],
    },
    {"role": "user", "content": "What time is it now?"},
]

One detail to remember: the injected tool message needs to be included again in later requests.

Responses API

Tool definitions use a flatter structure:

response = client.responses.create(
    model="kimi-k3",
    input="Hello",
    tools=[
        {
            "type": "function",
            "name": "get_weather",
            "description": "Get weather for a city",
            "parameters": {
                "type": "object",
                "properties": {"city": {"type": "string"}},
                "required": ["city"],
            },
        }
    ],
    tool_choice="required",
)

In testing, the model returned a function_call output item.

Claude-compatible Messages API

The Messages API uses Anthropic-style tool definitions:

from anthropic import Anthropic

client = Anthropic(
    api_key="<AIHUBMIX_API_KEY>",
    base_url="https://aihubmix.com",
)

response = client.messages.create(
    model="kimi-k3",
    max_tokens=4096,
    tools=[
        {
            "name": "get_weather",
            "description": "Get weather for a city",
            "input_schema": {
                "type": "object",
                "properties": {"city": {"type": "string"}},
                "required": ["city"],
            },
        }
    ],
    tool_choice={"type": "any"},
    messages=[{"role": "user", "content": "Hello"}],
)

The important caveat: dynamic tool loading did not take effect on the official Messages-compatible endpoint. Declare tools at the top level instead.

4. Structured output

Structured output works well through Chat Completions and Responses.

Chat Completions

completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": "Paris is the capital of France. Extract the city name.",
        }
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "extract",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {"city": {"type": "string"}},
                "required": ["city"],
            },
        },
    },
)

Observed output:

{"city":"Paris"}

Responses API

response = client.responses.create(
    model="kimi-k3",
    input="Paris is the capital of France. Extract the city name.",
    text={
        "format": {
            "type": "json_schema",
            "name": "extract",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {"city": {"type": "string"}},
                "required": ["city"],
            },
        }
    },
)

Messages API caveat

The Claude-compatible Messages endpoint did not support structured output in testing. The structured-output fields were silently ignored, and the endpoint returned free-form text with HTTP 200.

If your downstream code requires strict JSON, use Chat Completions or Responses for Kimi K3 structured output.

5. Context caching is automatic

Kimi K3 context caching is automatic. No special request parameter is required.

When a repeated long prefix hits the cache, the usage field varies by API:

API	Cache usage field
Chat Completions	`usage.prompt_tokens_details.cached_tokens`
Responses	`usage.input_tokens_details.cached_tokens`
Messages	`usage.cache_read_input_tokens`

This is especially useful for long system prompts, retrieval-heavy contexts, and agent workflows that reuse large prefixes.

6. Prefix completion

Prefix completion lets the model continue from an assistant prefix. This is useful for code completion, controlled formatting, or continuing a partially generated answer.

Chat Completions

messages = [
    {"role": "user", "content": "Write a haiku about the sea."},
    {"role": "assistant", "content": "Waves fold into foam,", "partial": True},
]

Responses and Messages

For Responses and Messages, pass the assistant prefix as the last assistant message. No separate partial parameter is needed.

7. Vision input

Kimi K3 supports image input. The exact content-block format depends on the API.

Chat Completions

messages = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "What is the dominant color of this image? One word."},
            {"type": "image_url", "image_url": {"url": "data:image/png;base64,<BASE64>"}},
        ],
    }
]

Responses API

input = [
    {
        "role": "user",
        "content": [
            {"type": "input_text", "text": "What is the dominant color of this image? One word."},
            {"type": "input_image", "image_url": "data:image/png;base64,<BASE64>"},
        ],
    }
]

Messages API

messages = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "What is the dominant color of this image? One word."},
            {
                "type": "image",
                "source": {
                    "type": "base64",
                    "media_type": "image/png",
                    "data": "<BASE64>",
                },
            },
        ],
    }
]

In a simple test using a 64x64 red PNG, the model correctly answered Red.

8. Stop sequence behavior

Kimi K3 validates stop sequence limits:

At most 5 stop sequences
Each sequence must be no longer than 32 bytes

Exceeding either limit returned HTTP 400 in testing.

One caveat: on the Messages API, a stop sequence hit did not follow Anthropic semantics. The response returned stop_reason: "end_turn" rather than stop_sequence, and stop_sequence was null.

If your client relies on those fields to detect truncation, add your own handling.

9. Latency: long Kimi K3 calls can take a while

Because Kimi K3 thinking is fixed at the max level, complex single-call tasks can take much longer than typical chat completions.

In one single-file HTML game generation test:

Total request time: 2,541 seconds, about 42 minutes
Completion tokens: 74,994
Thinking tokens: 54,486
Thinking share: 73% of completion tokens
Final result: 1,275 lines of runnable code
Finish reason: stop

For production clients:

Use streaming for long tasks
Set timeouts to minutes or longer
Leave enough room in max_completion_tokens
Track thinking-token usage when estimating cost and latency

Capability matrix

Capability	Chat Completions	Responses	Messages
Thinking content in response	`reasoning_content`	`reasoning` output item	`thinking` content block
Thinking history pass-back	Assistant message passed back verbatim	Output items passed back verbatim	Content blocks passed back verbatim
Force tool calls	`tool_choice: "required"`	`tool_choice: "required"`	`{"type": "any"}`
Disable tool calls	`tool_choice: "none"`	API-dependent	`{"type": "none"}`
Dynamic tool loading	Supported through system message with `tools`	In progress	Not supported in testing
Structured output	`response_format` with JSON Schema	`text.format` with JSON Schema	Not supported in testing
Automatic cache metering	`cached_tokens` in prompt details	`cached_tokens` in input details	`cache_read_input_tokens`
Prefix completion	`"partial": true`	Assistant prefill	Assistant prefill
Vision input	`image_url`	`input_image`	`image` block
Stop sequences	Validated limits	In progress	Limits validated, but stop metadata differs

FAQ

Which APIs does Kimi K3 support on AIHubMix?

AIHubMix supports Kimi K3 through Chat Completions, Responses, and the Claude-compatible Messages API.

Can Kimi K3 thinking be disabled?

No. Kimi K3 thinking is on by default, and reasoning_effort only supports "max".

Do I need to pass back `reasoning_content`?

Yes, for multi-turn Chat Completions. Preserve the previous assistant message complete and unmodified, including reasoning_content.

Does Kimi K3 support structured output?

Yes, through Chat Completions and Responses. In testing, the Messages-compatible endpoint did not support structured output.

Final thoughts

Kimi K3 is a strong option when you need long-context reasoning, tool calling, structured JSON, vision input, and cached-prefix workflows in one model.

The main things to watch are thinking history, long-task latency, API-specific syntax differences, and the Messages API caveats around structured output and stop sequence metadata.

For pricing and real-time status, see the Kimi K3 model page:

https://aihubmix.com/model/kimi-k3

For more models,including kimi-k3-free model pls visit:

https://aihubmix.com/models

DEV Community: AIHubMix

DeepSeek V4 Pro (0813) Across 3 APIs: Thinking Passback, Tool Calls, and Hidden 400s

The short version

1. Preserve thinking history verbatim

Chat Completions

Responses

Messages

2. Turning thinking off requires different fields

3. Tool schemas are protocol-specific

4. Structured output, caching, and web search

Production checklist

Nemotron 3.5 Lightning Is Now Free on AIHubMix

Built for the execution layer of AI agents

Lightning for execution, larger models for planning

Start using it for free

Seedance 2.5 vs MiniMax H3 vs Wan 3.0: An API-First Comparison

Model matrix

Model 1: Wan 3.0

Model 2: MiniMax H3

Model 3: Seedance 2.5

Calling the models through AIHubMix

Current AIHubMix billing

A repeatable evaluation harness

Test A: character continuity

Test B: product fidelity

Test C: temporal instruction following

Decision rules

References

Wan AI 3.0 API Tutorial: Use Alibaba Wan 3.0 on AIHubMix

What Is Wan AI 3.0?

Wan 3.0 on AIHubMix at a glance

Why Use Alibaba Wan Through AIHubMix?

Prerequisites

Generate a Wan 3.0 Video With cURL

Step 1: Submit the video job

Step 2: Poll the task status

Step 3: Download the video

Use Wan 3.0 With Python

How to Write Better Wan AI Prompts

1. Describe movement over time

2. Name a specific camera move

3. Protect identity and product details

4. Use constraints sparingly

Three Wan 3.0 Prompt Examples

Cinematic character scene

Ecommerce product video

Social media food clip

A Cost-Smart Testing Workflow

Common API Problems

The request returns an authorization error

The asynchronous endpoint is unavailable

The task stays queued

The Python client has no videos attribute

A long video loses consistency

Wan 3.0 FAQ

Is Wan 3.0 available now?

Is Wan 3.0 an Alibaba model?

Can Wan 3.0 generate a 30-second video?

Does AIHubMix support image-to-video with Wan 3.0?

How much does the Wan 3.0 API cost?

Start Building With Wan 3.0

DeepSeek V4 Flash Was Degraded Today. Here’s Why Multi-Provider Failover Matters

TL;DR

One Model Does Not Have to Mean One Provider

Layer 1: Provider Failover

Layer 2: Model Fallback

What Automatic Failover Can Handle

What Failover Cannot Solve

Why an Aggregator Can Be More Reliable Than a Direct Endpoint

Build for the Next Provider Incident

FAQ

What is multi-provider failover?

How is model fallback different?

Which failures can trigger failover?

Does failover guarantee zero downtime?

Do I need to change my application code?

Using Chinese AI Model APIs Outside China: Payment Options and Token Costs

How to Pay From Outside China

1. Self-Host Open Weights

2. Use an Aggregator Available in Your Region

The Python client has no `videos` attribute

1. Thinking mode: `reasoning_effort` only supports `max`

Do I need to pass back `reasoning_content`?