MiniMax Provider

The MiniMax provider offers access to the MiniMax-M series of language models through the MiniMax API, including models with reasoning capabilities, as well as video generation with the MiniMax-H series.

API keys can be obtained from the MiniMax Platform.

Setup

The MiniMax provider is available via the @ai-sdk/minimax module. You can install it with:

pnpm add @ai-sdk/minimax

Provider Instance

You can import the default provider instance minimax from @ai-sdk/minimax:

1
import { minimax } from '@ai-sdk/minimax';

For custom configuration, you can import createMiniMax and create a provider instance with your settings:

1
import { createMiniMax } from '@ai-sdk/minimax';
2

3
const minimax = createMiniMax({
4
  apiKey: process.env.MINIMAX_API_KEY ?? '',
5
});

You can use the following optional settings to customize the MiniMax provider instance:

• baseURL string

  Use a different URL prefix for API calls. This provider speaks MiniMax's Anthropic-compatible protocol, so the default prefix is https://api.minimax.io/anthropic/v1 — not the OpenAI-compatible https://api.minimax.io/v1.

• videoBaseURL string

  Use a different URL prefix for video generation API calls. The video API uses the MiniMax V2 native endpoint (not the Anthropic-compatible endpoint). The default prefix is https://api.minimax.io.

• apiKey string

  API key for the MiniMax API. It defaults to the MINIMAX_API_KEY environment variable. Language models send it in the x-api-key header (the Anthropic-compatible protocol); video models send it as Authorization: Bearer.

• headers Record<string,string>

  Custom headers to include in the requests

• fetch (input: RequestInfo, init?: RequestInit) => Promise<Response>

  Custom fetch implementation

Language Models

You can create language models using a provider instance:

1
import { minimax } from '@ai-sdk/minimax';
2
import { generateText } from 'ai';
3

4
const { text } = await generateText({
5
  model: minimax('minimax-m3'),
6
  prompt: 'Write a vegetarian lasagna recipe for 4 people.',
7
});

You can also use the .chat() or .languageModel() factory methods:

1
const model = minimax.chat('minimax-m3');
2
// or
3
const model = minimax.languageModel('minimax-m3');

MiniMax language models can be used in the streamText function (see AI SDK Core).

Reasoning

MiniMax-M models can produce intermediate reasoning ("thinking") before their final response. You control this behavior through provider options. The reasoning output is streamed through the standard AI SDK reasoning parts.

1
import { minimax, type MiniMaxLanguageModelOptions } from '@ai-sdk/minimax';
2
import { generateText } from 'ai';
3

4
const { text, reasoningText } = await generateText({
5
  model: minimax('minimax-m3'),
6
  providerOptions: {
7
    minimax: {
8
      thinking: { type: 'adaptive' },
9
    } satisfies MiniMaxLanguageModelOptions,
10
  },
11
  prompt: 'How many "r"s are in the word "strawberry"?',
12
});
13

14
console.log(reasoningText);
15
console.log(text);

See AI SDK UI: Chatbot for more details on how to integrate reasoning into your chatbot.

Provider Options

The following optional provider options are available for MiniMax language models:

• thinking object

  Controls the model's reasoning ("thinking") behavior.

  • type 'adaptive' | 'disabled'
    • 'adaptive': the model decides when to reason (deep reasoning enabled)
    • 'disabled': the model responds directly without reasoning, for higher throughput and lower latency

  When omitted, the model uses its provider-side default.

  Thinking control is only supported on minimax-m3. The M2.x models always think, so 'disabled' has no effect on them.

Video Models

You can generate videos with the MiniMax-H3 model using the experimental_generateVideo function:

1
import { minimax, type MiniMaxVideoModelOptions } from '@ai-sdk/minimax';
2
import { experimental_generateVideo as generateVideo } from 'ai';
3

4
const { video } = await generateVideo({
5
  model: minimax.video('MiniMax-H3'),
6
  prompt: 'A white kitten chases a butterfly across a sunlit garden.',
7
  aspectRatio: '16:9',
8
  duration: 5,
9
  providerOptions: {
10
    minimax: {
11
      pollTimeoutMs: 600000, // 10 minutes
12
    } satisfies MiniMaxVideoModelOptions,
13
  },
14
});

MiniMax-H3 generates one video per call. Generation is asynchronous — the model creates a task and polls until it completes, then returns the resulting MP4 URL.

duration accepts a whole number of seconds from 5 to 15, and defaults to 5. A fractional value is rounded and an out-of-range value is clamped, each with a warning. The only supported output resolution is 2K.

For text-to-video, aspectRatio defaults to 16:9 when omitted. The MiniMax API requires a concrete ratio for text-only requests and does not accept adaptive. For reference-to-video, the API default is adaptive when aspectRatio is omitted. For image-to-video with frame images, the aspect ratio follows the input image.

Generation modes

The generation mode is inferred from the inputs you pass:

• Text-to-video — prompt only.
• First-frame image-to-video — pass image (or a frameImages entry with frameType: 'first_frame') to animate a starting image.
• First-to-last keyframes — pass frameImages with both a first_frame and a last_frame to control the transition.
• Reference-to-video — pass inputReferences (images and/or videos, routed by media type) to keep a subject/style or follow motion. Frame images and references are mutually exclusive.

When a frame image is supplied, the aspect ratio follows the image and any explicit aspectRatio is ignored.

Video Provider Options

The following optional provider options are available for MiniMax video models:

• resolution string

  Output resolution. MiniMax-H3 currently only supports '2K' (the default).

• ratio 'adaptive' | '21:9' | '16:9' | '4:3' | '1:1' | '3:4' | '9:16'

  Aspect ratio of the generated video. Overrides the top-level aspectRatio.

• referenceAudioUrls string[]

  Reference audio URLs (or mm_file:// handles) for reference-to-video generation. Must be paired with at least one reference image or video. Up to 3.

• aigcWatermark boolean

  Whether to embed an AIGC watermark in the output. Defaults to false.

• pollIntervalMs number

  Interval in milliseconds between task status polls. Default: 10000.

• pollTimeoutMs number

  Maximum time in milliseconds to poll before timing out. Default: 600000.

Video Provider Metadata

MiniMax video results include providerMetadata.minimax:

• taskId string

  ID of the MiniMax generation task.

• videoUrl string

  The MiniMax-hosted MP4 URL (the same URL as video). Time-limited.

• resolvedInputs object

  The inputs that were actually sent, after the caps and rejections H3 imposes (warnings report that an input was dropped, but not how many survived).

  • imageCount number — number of images sent (frame images or reference images).
  • referenceVideoUrls string[] — the URLs of the reference videos sent. Inline video data is omitted, since it is sent as a data URI.

• duration number

  Duration of the generated video in seconds, when reported by the API.

• ratio string

  Aspect ratio of the generated video, when reported by the API.

• resolution string

  Resolution tier of the generated video, when reported by the API.

• usage object

  Billed seconds, when reported by the API: totalSeconds, inputSeconds, and outputSeconds.

Model Capabilities