Xiaomi MiMo-V2.6-Pro Omnimodal Input and Visual Task Workflow

One-sentence conclusion

mimo-v2.6-pro can read publicly accessible URLs or properly formatted Base64 images, videos, and audio through the OpenAI Chat Completions API, but it cannot directly upload local files, and the combined media and text tokens remain subject to the 1M context limit.

Applicable scenarios

• Suitable tasks: Image description and classification, multi-image difference analysis, video content and temporal analysis, audio content analysis, and structured summaries generated from these tasks.

• Unsuitable tasks: Passing a local path directly to the API; the official documentation explicitly states that mimo-v2.6-pro does not currently support local uploads of image, video, or audio files. For dedicated speech-recognition tasks that require verbatim transcription, evaluate the official mimo-v2.5-asr separately; this article does not treat the multimodal-understanding examples as an ASR evaluation.

• Applicable model version: mimo-v2.6-pro. The official pages also list mimo-v2.6-flash, mimo-v2.6-pro-ultraspeed, and mimo-v2.5, but the code, limitations, and conclusions in this article apply only to Pro.

• Applicable clients, Agents, or APIs: OpenAI Chat Completions API and the Python openai SDK; the examples use https://api.xiaomimimo.com/v1.

• Recommended reasoning mode and parameters: Start with the official example's max_completion_tokens=1024 for connectivity checks. Adjust fps for video temporal tasks and media_resolution for visual detail. For complex media analysis, the output budget can be increased, but media tokens, text tokens, and output budget must be checked together against the context limit.

Ready-to-use content

Image URL: description or classification

The following request structure comes from the official image-understanding page. Replace the API key, image URL, and task text before running it:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["MIMO_API_KEY"],
    base_url="https://api.xiaomimimo.com/v1",
)

completion = client.chat.completions.create(
    model="mimo-v2.6-pro",
    messages=[
        {
            "role": "system",
            "content": "You are MiMo, an AI assistant developed by Xiaomi.",
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://example.com/image.png"
                    },
                },
                {
                    "type": "text",
                    "text": "Describe the image and group the result by subjects, scene, actions, and uncertainties.",
                },
            ],
        },
    ],
    max_completion_tokens=1024,
)

print(completion.model_dump_json())

Image Base64: images that cannot be publicly accessed

Under the OpenAI-compatible protocol, image_url.url must include the data:{MIME_TYPE};base64, prefix; $BASE64_IMAGE itself should contain only the raw Base64 string.

import base64

with open("image.png", "rb") as f:
    base64_image = base64.b64encode(f.read()).decode("ascii")

image_url = f"data:image/png;base64,{base64_image}"

completion = client.chat.completions.create(
    model="mimo-v2.6-pro",
    messages=[
        {"role": "user", "content": [
            {"type": "image_url", "image_url": {"url": image_url}},
            {"type": "text", "text": "Identify the key fields in the image and mark any fields that cannot be confirmed."},
        ]},
    ],
    max_completion_tokens=1024,
)

Video URL: adjust frame rate and resolution

The official video example uses video_url, sets fps to 2, and sets media_resolution to default:

completion = client.chat.completions.create(
    model="mimo-v2.6-pro",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "video_url",
                    "video_url": {
                        "url": "https://example.com/video.mp4"
                    },
                    "fps": 2,
                    "media_resolution": "default",
                },
                {
                    "type": "text",
                    "text": "Summarize the events in the video in chronological order and identify key changes in the frames.",
                },
            ],
        },
    ],
    max_completion_tokens=1024,
)

Increase fps when actions change quickly or finer temporal localization is needed. Use media_resolution="max" when the focus is on small objects or textures. These two fields belong to the video input item; they are not model-name or reasoning-mode parameters.

Audio URL: content analysis

The official audio example passes a public URL through input_audio.data:

completion = client.chat.completions.create(
    model="mimo-v2.6-pro",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_audio",
                    "input_audio": {
                        "data": "https://example.com/audio.wav"
                    },
                },
                {
                    "type": "text",
                    "text": "Summarize the audio, distinguishing information about speakers that can be confirmed from information that is uncertain.",
                },
            ],
        },
    ],
    max_completion_tokens=1024,
)

Audio Base64 still uses the data:{MIME_TYPE};base64,$BASE64_AUDIO form:

audio_data = f"data:audio/wav;base64,{base64_audio}"

Test/workflow steps

1. Prepare MIMO_API_KEY, install the openai SDK, and confirm that the media address is publicly accessible; do not put a local path or real key in the request.

2. First send a small PNG or a short audio clip with max_completion_tokens=1024. Confirm that the model in the response is mimo-v2.6-pro and that choices[0].message.content is non-empty.

3. Test both image input methods: a public URL and data:{MIME_TYPE};base64,. Check that the MIME type matches the actual file. Use only the JPEG, PNG, GIF, WebP, or BMP formats listed in the official documentation.

4. For video, start with fps=2 and media_resolution="default", then change only one variable at a time for comparison: increase fps for fast motion and switch to max for detail recognition. Confirm that the URL, format, and file size meet the limits.

5. For audio, start with a WAV or MP3 URL and then test Base64. Check usage.prompt_tokens_details.audio_tokens in the response if that field is provided, and compare its order of magnitude with the official estimate of duration in seconds multiplied by 6.25.

6. Record the following for every request: model ID, media type, URL/Base64 method, MIME type, media size, video fps/media_resolution, text question, max_completion_tokens, response usage, and error information.

7. If the response is empty, the media cannot be recognized, or a context/size error occurs, first shorten the media or reduce the video fps/resolution and retry; do not assume that the model understood the media merely because HTTP succeeded.

Original evidence and data

Image understanding

• The official page directly lists the supported models: mimo-v2.6-flash, mimo-v2.6-pro, mimo-v2.6-pro-ultraspeed, and mimo-v2.5.

• Public image URLs and Base64 are both supported; the URL and Base64 forms for each single image must not exceed 50 MB.

• Supported formats: JPEG, PNG, GIF, WebP, and BMP.

• The number of images is limited by the model context; the total tokens for images and text must be less than the model context length.

• The official documentation states that Pro does not currently support local file uploads.

• The official example response has model set to mimo-v2.6-pro and shows the image_tokens usage field; actual usage is determined by the API response.

Video understanding

• The official page directly lists the supported models: mimo-v2.6-flash, mimo-v2.6-pro, mimo-v2.6-pro-ultraspeed, and mimo-v2.5.

• Public video URLs and Base64 are supported; a single video URL must not exceed 300 MB, and the Base64 string must not exceed 50 MB.

• Supported formats: MP4, MOV, AVI, and WMV. The official documentation warns that there are many format variants and recognition must be confirmed through testing.

• The number of videos is limited by the context; the total tokens for all videos and text must be less than the model context length.

• fps defaults to 2 and ranges from [0.1, 10]; a higher value samples frames more densely, captures more temporal detail, and consumes more tokens.

• media_resolution supports default and max; default balances quality and efficiency, while max improves recognition of small objects and detailed textures.

• Video tokens are divided into video_tokens and audio_tokens. The official page estimates audio tokens at approximately audio duration in seconds multiplied by 6.25. All estimates are for reference only; actual usage is determined by the response.

• The official documentation states that Pro does not currently support local video file uploads.

Audio understanding

• The official page directly lists the supported models: mimo-v2.6-flash, mimo-v2.6-pro, mimo-v2.6-pro-ultraspeed, and mimo-v2.5.

• Public audio URLs and Base64 are supported; a single audio URL must not exceed 100 MB, and the Base64 string must not exceed 50 MB.

• Supported formats: MP3, WAV, FLAC, M4A, and OGG. The official documentation warns that there are many format variants and recognition must be confirmed through testing.

• The number of audio files is limited by the context; the total tokens for all audio and text must be less than the model context length.

• The official documentation estimates audio tokens at approximately audio duration in seconds multiplied by 6.25; actual usage is determined by the API response.

• The official documentation states that Pro does not currently support local audio file uploads.

Scope and limitations

• A “supported models” list proves that the official API accepts the model for omnimodal input; it is not an independent benchmark of image, video, or audio understanding.

• A public URL must be accessible to the server. Do not assume that private-network URLs, expired signed URLs, or links requiring login will work.

• The 50 MB limit for Base64 applies to the encoded string size and does not mean that an original file can safely reach 50 MB; leave headroom for encoding expansion and request-body limits.

• Multimedia tokens, text, and output all consume the context; even when an individual file is below the size limit, a combined input may still exceed the context limit.

• Increasing video fps increases input tokens and latency; media_resolution="max" also increases cost and must be chosen according to the task.

• The dates, system prompt, and max_completion_tokens=1024 in the official examples are sample configurations, not the only values required by Pro.

• The documentation does not provide a local-file-upload interface for the tasks in this article. Do not try to bypass the limitation by guessing field names or using another browser method.

• The documentation does not promise recognition of every media-encoding variant, speaker diarization, timestamp precision, or OCR accuracy; these capabilities must be validated on your own samples.

Source excerpts or observations (short compliance excerpts only)

1. Image understanding (official): The page says that images can be supplied by URL or Base64 and explicitly shows mimo-v2.6-pro in the example's model; it also lists the 50 MB single-image limit, supported formats, and multi-image context limit.

2. Video understanding (official): The page says that videos can be supplied by URL or Base64 and explicitly uses video_url, fps, and media_resolution; it also lists the 300 MB URL limit, 50 MB Base64 limit, the fps range [0.1, 10], and the default/max resolution modes.

3. Audio understanding (official): The page says that audio can be supplied by URL or Base64 and explicitly uses input_audio.data; it also lists the 100 MB URL limit, 50 MB Base64 limit, supported formats, and the estimate of approximately 6.25 tokens/second.

4. The FAQs on all three pages explicitly state that mimo-v2.6-pro does not currently support local file uploads. This article therefore provides only URL and Base64 workflows.