MiniMax API Access With One OpenAI-Compatible Router

MiniMax API Access With One OpenAI-Compatible Router is useful when your team wants MiniMax in the same production workflow as the rest of your AI stack. The direct MiniMax path is already OpenAI SDK-compatible for supported language models. A router path adds one shared base URL, one key layer, one catalog check, one usage log, and one place to decide which MiniMax workloads should sit beside GPT, Claude, Gemini, DeepSeek, Qwen, Seedance, Veo, and other model routes.

This refresh was checked on September 16, 2026 against MiniMax official API documentation, MiniMax pay-as-you-go pricing, Flatkey public docs, the Flatkey model directory, and Flatkey MiniMax model pages. Treat every model, price, and route status as a dated public snapshot. Re-check your account, catalog, and terms before sending production traffic.

The short version: use direct MiniMax when you only need MiniMax account access. Use Flatkey when MiniMax needs to be evaluated, budgeted, logged, and rolled back inside a multi-provider router workflow.

Quick Answer: MiniMax API Access With One OpenAI-Compatible Router

If your app already uses the OpenAI Python or JavaScript SDK, MiniMax has two practical access paths:

Decision	Direct MiniMax	MiniMax through Flatkey
API key	MiniMax pay-as-you-go API key	Flatkey API key
Base URL for OpenAI-style chat	https://api.minimax.io/v1	https://router.flatkey.ai/v1
Direct language model checked	MiniMax-M3 in MiniMax docs	Check the live Flatkey catalog; public refresh verified minimax-m2.7 as a chat route, not minimax-m3
Video route checked	MiniMax POST /v2/video_generation with MiniMax-H3 or MiniMax-H3-Max	Flatkey POST /v1/videos with MiniMax-H3
Best use	Provider-direct MiniMax integration	One router for route testing, usage logs, billing review, quotas, fallback policy, and rollback
Main risk	Assuming OpenAI-compatible means full OpenAI feature parity	Assuming every MiniMax model in official docs is already available in your Flatkey account

Use this MiniMax API Access With One OpenAI-Compatible Router guide as the launch checklist. Do not approve the migration just because one sample response worked. Approve it when the exact model ID, endpoint, request shape, pricing unit, usage log, fallback rule, and rollback path are all visible.

What Changed Since The Older MiniMax Article

The older public article was dated June 16, 2026. The safe refresh is not a cosmetic rewrite. MiniMax and Flatkey both moved enough that the article needs current route language.

The key updates are:

• MiniMax now documents MiniMax-M3 as the latest M-series OpenAI SDK-supported language model, with a 1,000,000-token context window and image/video input support through OpenAI-compatible message content parts.
• MiniMax video generation V2 now documents MiniMax-H3 and MiniMax-H3-Max through an asynchronous POST /v2/video_generation flow.
• MiniMax pay-as-you-go pricing now separates M3 text pricing by context threshold and service tier, H3 video pricing by model/resolution/seconds, image pricing by generated image, speech pricing by hour or character, and MCP/tool pricing by request.
• Flatkey public docs expose MiniMax-H3 through the shared POST /v1/videos asynchronous video workflow.
• Flatkey public model pages checked during this refresh returned 200 for https://flatkey.ai/models/minimax-h3 and https://flatkey.ai/models/minimax-m2.7; https://flatkey.ai/models/minimax-m3 returned 404. That means this article does not claim a verified Flatkey M3 route.

That last point matters. A router article should help teams avoid stale model-name assumptions. If you want M3 through Flatkey, check the live model directory, /v1/models, or your console before you configure production traffic.

Source Facts To Lock Before You Route MiniMax

Use this source table before changing code:

Fact	Current public source snapshot	Production use
Direct OpenAI SDK base URL	MiniMax OpenAI SDK docs use https://api.minimax.io/v1.	Keep direct MiniMax and Flatkey credentials separate.
Direct language model	MiniMax docs list MiniMax-M3 as the latest M-series model for agentic reasoning, tool use, coding, long context, and multimodal tasks.	Test M3 directly first if your workload depends on M3-specific behavior.
MiniMax OpenAI-compatible caveats	MiniMax docs say some OpenAI parameters may be ignored, n only supports 1, deprecated function_call is not supported, and audio input is not currently supported in the OpenAI-compatible message-content path.	Build a feature smoke test instead of assuming full parity.
Direct video endpoint	MiniMax video V2 uses POST /v2/video_generation and returns a task_id for polling.	Treat video as an async job, not a synchronous chat call.
Direct video models	MiniMax docs list MiniMax-H3 and MiniMax-H3-Max.	Choose by required duration, resolution, input type, and cost.
Flatkey router base URL	Flatkey docs use https://router.flatkey.ai/v1 for OpenAI SDK and REST API calls.	Use one configurable router base URL with a Flatkey key.
Flatkey MiniMax H3 video route	Flatkey docs and model page expose MiniMax-H3 through POST /v1/videos.	Use Flatkey's video task flow, then verify usage logs.
Flatkey M3 route status	Public minimax-m3 model detail returned 404 during this refresh.	Do not claim M3 is routable through Flatkey unless your current catalog/account confirms it.

This is the main production habit behind MiniMax API Access With One OpenAI-Compatible Router: save the source date, save the model ID, and save the evidence path. Model catalogs change too often for copied snippets to be the final authority.

Direct MiniMax OpenAI SDK Setup

Direct MiniMax setup is the cleanest first test when you need to understand provider-native behavior.

export OPENAI_BASE_URL="https://api.minimax.io/v1"
export OPENAI_API_KEY="your-minimax-api-key"
export MINIMAX_MODEL="MiniMax-M3"

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["OPENAI_API_KEY"],
    base_url=os.environ["OPENAI_BASE_URL"],
)

response = client.chat.completions.create(
    model=os.environ.get("MINIMAX_MODEL", "MiniMax-M3"),
    messages=[
        {"role": "user", "content": "Return one sentence confirming the MiniMax route works."}
    ],
    max_completion_tokens=120,
    extra_body={
        "thinking": {"type": "disabled"}
    },
)

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

Use direct MiniMax to learn the provider behavior first:

• Does your app need MiniMax thinking output or direct answers?
• Does your stream handler tolerate MiniMax response fields?
• Does your tool-call loop append the full assistant message when required?
• Does your parser depend on parameters MiniMax ignores?
• Does your workload use image or video input parts with MiniMax-M3?
• Does your app accidentally expect audio input in the OpenAI-compatible chat path?

That direct test gives you the baseline before you put MiniMax behind a router.

Flatkey Setup For MiniMax Through One Router

For Flatkey, the OpenAI-compatible client setup is the same pattern used for other models: use a Flatkey key, set the Flatkey router base URL, and choose a model ID that exists in the current Flatkey catalog.

export FLATKEY_API_KEY="sk-your-flatkey-key"
export OPENAI_BASE_URL="https://router.flatkey.ai/v1"

# Example public chat route verified in this refresh.
export FLATKEY_MINIMAX_TEXT_MODEL="minimax-m2.7"

# Example public video route verified in this refresh.
export FLATKEY_MINIMAX_VIDEO_MODEL="MiniMax-H3"

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["FLATKEY_API_KEY"],
    base_url=os.environ.get("OPENAI_BASE_URL", "https://router.flatkey.ai/v1"),
)

response = client.chat.completions.create(
    model=os.environ["FLATKEY_MINIMAX_TEXT_MODEL"],
    messages=[
        {"role": "user", "content": "Return one sentence confirming the Flatkey MiniMax route works."}
    ],
    max_tokens=120,
)

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

This is the basic MiniMax API Access With One OpenAI-Compatible Router pattern. The code stays ordinary, but the model ID must come from Flatkey on the day you test. If the current catalog shows MiniMax-M3, use the exact current string. If it does not, do not paste the direct MiniMax model ID into a Flatkey route and assume it will work.

Video: MiniMax H3 Through Flatkey

For media teams, MiniMax API access is often about video rather than chat. Flatkey documents MiniMax-H3 through a dedicated asynchronous video workflow:

curl --fail-with-body -sS https://router.flatkey.ai/v1/videos \
  -H "Authorization: Bearer $FLATKEY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "MiniMax-H3",
    "content": [
      {
        "type": "text",
        "text": "A paper boat crosses a rain puddle in a cinematic macro shot"
      }
    ],
    "resolution": "768P",
    "duration": 6,
    "ratio": "16:9",
    "aigc_watermark": false
  }'

Flatkey's MiniMax H3 guide says the response includes an id and task_id. Save it, poll GET /v1/videos/{task_id}, then download the file from metadata.url when the task is completed.

The video setup is not interchangeable with a chat completion:

• MiniMax-H3 uses the content array shape.
• resolution is case-sensitive and accepts 768P or 2K in the Flatkey guide.
• duration is an integer from 4 through 15 seconds.
• Text-only requests need a non-adaptive ratio.
• Reference media and first/last-frame controls have different role rules.
• Usage fields represent seconds for H3 video responses, not language-model tokens.

If your product also compares Seedance, Veo, or other video models, pair this article with Flatkey's multi-provider video routing checks. The key is not only whether a video task succeeds. The key is whether the output contract, cost unit, queue behavior, failure state, and fallback rule are acceptable for the workflow.

MiniMax Pricing Units To Normalize

Pricing is where MiniMax API Access With One OpenAI-Compatible Router can go wrong. MiniMax is not one price table. It is several pricing units.

MiniMax surface	Direct MiniMax pricing unit checked September 16, 2026	Router planning note
MiniMax-M3 standard text, up to 512k input tokens	$0.30 / M input tokens, $1.20 / M output tokens, $0.06 / M prompt caching read after the listed permanent discount	Compare input, output, cached input, and context threshold separately.
MiniMax-M3 standard text, over 512k input tokens	$0.60 / M input tokens, $2.40 / M output tokens, $0.12 / M prompt caching read after the listed permanent discount	Long-context prompts can change the cost class.
MiniMax-M3 priority tier	MiniMax states Priority is 1.5x standard and is enabled with service_tier: priority.	Treat admission tier as a cost and reliability decision.
MiniMax-H3 video	$0.08 / second at 768P and $0.13 / second at 2K.	Calculate cost per accepted clip, not only cost per generated second.
MiniMax-H3-Max video	$0.05 / second at 480P and $0.08 / second at 768P.	Lower resolution can be the correct draft lane if quality passes.
Speech-to-text	$0.38 / hour.	Track audio duration, diarization/subtitle needs, and retry behavior.
Text-to-speech	speech-2.8-turbo at $60 / M characters; speech-2.8-hd at $100 / M characters.	Character count and accepted audio rate matter more than request count.
Image generation	image-01 at $0.0035 per image.	Normalize by accepted image after moderation and creative review.
API-vlm / server tools	API-vlm and web_search rows show request-based pricing.	Treat request tools separately from token or media generation.

Flatkey prices and group multipliers are separate from direct MiniMax pricing. The direct provider table tells you how MiniMax bills a MiniMax account. A Flatkey routing decision should use the live Flatkey model row, your account group, and the usage log after a test request.

Use this formula for media and creator workflows:

accepted_output_cost:
  provider_or_router_cost: "sum of all attempts"
  accepted_outputs: "clips, images, audio files, or responses that passed review"
  formula: "provider_or_router_cost / accepted_outputs"
  include:
    - retries
    - fallback attempts
    - rejected outputs
    - regeneration
    - review lane
    - storage handoff

The cheapest generated output is not always the cheapest accepted output.

Compatibility Smoke Test

Run this smoke test before moving any production traffic:

Test	Direct MiniMax	Flatkey router
Auth and base URL	MiniMax key with https://api.minimax.io/v1.	Flatkey key with https://router.flatkey.ai/v1.
Model ID	MiniMax-M3, MiniMax-H3, or another current direct MiniMax model.	Exact current Flatkey model ID from /v1/models, model directory, or console.
Basic chat	Confirm response shape and usage.	Confirm response shape and Usage Logs.
Streaming	Confirm chunks and final usage behavior.	Confirm stream chunks, timeout behavior, and log fields.
Tool calls	Use tools, not deprecated function_call.	Confirm the same schema passes through the chosen route.
Multimodal input	Test image/video content parts for M3 if used.	Only test payloads supported by the exact Flatkey route.
Video job	Use MiniMax POST /v2/video_generation and poll.	Use Flatkey POST /v1/videos, poll, and download from metadata.url.
Pricing	Check MiniMax pay-as-you-go units.	Check Flatkey catalog price, usage row, key, route, and final deducted cost.
Failure handling	Record 400, 401, 402, 422, 429, and 5xx behavior.	Record route-unavailable, validation, timeout, and retry behavior.
Rollback	Keep direct MiniMax config or previous provider config.	Keep model and route configurable without a code deployment.

The pass condition is evidence, not confidence. Save a request ID or task ID, a model ID, a timestamp, the route path, a usage-log screenshot or export, and the final cost unit.

Copyable MiniMax Route Review Record

Use this template in your launch issue or routing repository:

minimax_route_review:
  checked_at_utc: "2026-09-16T00:00:00Z"
  owner: "media_platform_team"
  workload: "creator_video_draft | support_chat | voiceover | image_draft"
  route_mode: "direct_minimax | flatkey | dual_route_test"
  direct_minimax:
    base_url: "https://api.minimax.io/v1"
    model_id: "MiniMax-M3"
    docs_checked:
      - "https://platform.minimax.io/docs/api-reference/text-openai-api.md"
      - "https://platform.minimax.io/docs/guides/pricing-paygo.md"
  flatkey:
    base_url: "https://router.flatkey.ai/v1"
    model_id: "replace_with_current_flatkey_model_id"
    catalog_url: "https://flatkey.ai/models"
    model_page_status: "200 | 404 | account_only"
    usage_logs_verified: false
  endpoint_contract:
    path: "/v1/chat/completions | /v1/videos"
    request_shape: "chat_messages | content_array | prompt_string"
    streaming_required: false
    tool_calls_required: false
    image_input_required: false
    video_input_required: false
  cost_review:
    provider_unit: "tokens | seconds | characters | images | hours | requests"
    flatkey_unit: "record current row"
    accepted_output_cost_target: "USD"
  fallback_policy:
    fallback_enabled: false
    fallback_models: []
    allowed_failure_classes:
      - "timeout"
      - "upstream_5xx"
    blocked_failure_classes:
      - "safety_block"
      - "unsupported_feature"
  rollout:
    first_environment: "staging"
    production_slice: "0%"
    rollback_owner: "engineering"
    next_review_date: "YYYY-MM-DD"

This record turns MiniMax API Access With One OpenAI-Compatible Router into an auditable decision. Anyone should be able to see which model was tested, which route handled it, which cost unit was approved, and which fallback behavior is allowed.

When Direct MiniMax Is Enough

Use direct MiniMax when:

• MiniMax is the only provider in the workflow.
• You need a newly launched MiniMax model before it appears in a gateway catalog.
• You need a provider-native feature that the router does not expose.
• Procurement or data policy requires direct provider controls.
• Your team is still learning MiniMax behavior and wants a clean baseline.

Direct access is not a failure of architecture. It is the right path when provider specificity matters more than centralization.

When Flatkey Is The Cleaner Path

Use Flatkey when MiniMax is one route in a broader model system:

• The product compares MiniMax with GPT, Claude, Gemini, DeepSeek, Qwen, Seedance, Veo, or other providers.
• A creator workflow needs text, image, speech, and video routes under one review process.
• Finance wants one request-level usage trail instead of several provider consoles.
• Platform owners need sub-keys, quotas, model allowlists, route reviews, or rollback controls.
• The team already uses OpenAI SDK clients and wants model choice in configuration.
• Fallback and route-health decisions need to be observable.

Flatkey does not remove provider-level testing. It makes the testing and evidence easier to manage across providers.

Common Mistakes

• Mixing credentials: a MiniMax key belongs with the MiniMax base URL, and a Flatkey key belongs with the Flatkey base URL.
• Using MiniMax-M3 in Flatkey code without checking that the current Flatkey catalog exposes that exact route.
• Treating direct MiniMax OpenAI SDK compatibility as full OpenAI API parity.
• Ignoring MiniMax caveats around unsupported deprecated function_call, n: 1, ignored parameters, and audio input in the OpenAI-compatible chat path.
• Testing only chat when the production workload uses streaming, tools, image input, video input, or asynchronous video jobs.
• Comparing token prices, video seconds, speech characters, and image prices in one table without normalizing by accepted output.
• Enabling fallback from one video model to another without checking duration, resolution, audio/reference support, and moderation behavior.
• Publishing sample code with real-looking keys or stale model IDs.

Internal Links For The Next Step

If this is your first Flatkey migration, start with the Flatkey API quickstart and the broader unified AI API workflow. For model row review, use the AI model catalog guide. For video policy, pair this with Seedance vs Veo API routing, the Veo API access checklist, and the multimodal agent routing guide.

FAQ

How do I get MiniMax API access?

You can get MiniMax API access directly through the MiniMax platform with a pay-as-you-go API key, or route supported MiniMax models through Flatkey with a Flatkey key and https://router.flatkey.ai/v1. Use direct MiniMax for provider-native testing and Flatkey for multi-provider routing, logs, billing review, and fallback policy.

Is the MiniMax API OpenAI compatible?

MiniMax documents OpenAI SDK usage with https://api.minimax.io/v1 as the base URL for supported language models. Compatibility is feature-level. MiniMax documents caveats around ignored OpenAI parameters, n: 1, unsupported deprecated function_call, and no audio input in the OpenAI-compatible chat message-content path.

What is the current MiniMax language model to check first?

MiniMax official docs list MiniMax-M3 as the latest M-series language model, with a 1,000,000-token context window and multimodal support for image and video input. For Flatkey, check the live catalog before assuming that exact model ID is available through the router.

Can I use MiniMax-M3 through Flatkey?

Do not assume it from direct MiniMax docs alone. During this September 16, 2026 refresh, the public Flatkey minimax-m3 model detail page returned 404, while minimax-m2.7 and MiniMax-H3 returned 200. Check your current Flatkey model directory, /v1/models, or console before configuring M3 through Flatkey.

How do I use MiniMax-H3 video through Flatkey?

Use POST https://router.flatkey.ai/v1/videos with model MiniMax-H3, a content array, resolution of 768P or 2K, a duration from 4 through 15, and a valid ratio. Save the returned task ID, poll GET /v1/videos/{task_id}, then download from metadata.url when completed.

How should I compare MiniMax pricing through a router?

Start from the direct MiniMax unit, then check the Flatkey model row and your usage log. Text uses token units, video uses seconds, speech can use hours or characters, image generation uses per-image pricing, and tools can use per-request pricing. Compare cost per accepted output after retries and rejected outputs, not only list price.

Does Flatkey replace direct MiniMax route testing?

No. Flatkey can centralize key management, model routing, usage logs, and billing review, but you still need to test the exact model, endpoint, request shape, price unit, fallback rule, and error behavior your product will use.

Final Takeaway

MiniMax API Access With One OpenAI-Compatible Router should end with a dated route record, not just a changed base_url. Confirm direct MiniMax behavior, pick the exact Flatkey model row if you route through Flatkey, run chat and video smoke tests separately, normalize pricing by accepted output, and keep rollback in configuration. Then use Flatkey's model directory, pricing page, quickstart, video docs, and usage logs to keep MiniMax inside the same operational review loop as the rest of your model stack.

For media and product teams, MiniMax API Access With One OpenAI-Compatible Router is the practical habit of treating every model launch as a route decision with evidence attached.