DeepSeek-V4.1-Flash-1017 is a minor update to DeepSeek-V4.1-Flash, delivering substantial improvements across reasoning, coding, agentic tasks, and visual benchmarks. Alongside these gains, the model reduces task execution time and output length, enabling users to complete tasks faster and at lower cost and advancing the performance–cost Pareto frontier across multiple agent harnesses.

DeepSeek-V4.1-Flash-1017

NVIDIA Nemotron 3.5 Super VL is an open multimodal model for agents that see, reason, and act. Its 120B-parameter Mixture-of-Experts design (12B active) understands text, images, documents, GUIs, and video, and adds reasoning and tool use on top.

NVIDIA-Nemotron-3.5-Super-VL

Hy4 preview is a 770B-parameter Mixture-of-Experts flagship model from the Tencent Hy Team, with 49B parameters activated per token and a 1M-token context window. It uses Gated DeepSeek Sparse Attention with IndexCache, and is post-trained for software engineering, office and data analysis, game development, and scientific research.

Hy4-preview

MiMo-V2.6-Flash is the efficiency-balanced model in Xiaomi's MiMo-V2.6 series: a sparse Mixture-of-Experts model with 309B total and 15B activated parameters, natively omnimodal across text, image, video and audio, with a 1M-token context window. Trained with large-scale mixed reinforcement learning across coding, general agents, visual and cybersecurity tasks, it is built for agentic workloads such as long-horizon coding, tool use and computer use.

MiMo-V2.6-Flash

MiMo-V2.6-Pro is the flagship of Xiaomi's MiMo-V2.6 series: a sparse Mixture-of-Experts model with 1.02T total and 42B activated parameters, natively omnimodal across text, image, video and audio, with a 1M-token context window. Trained with large-scale mixed reinforcement learning and groupwise agentic grading, it is built for demanding agentic work including long-horizon coding, multi-tool agents and cybersecurity tasks.

MiMo-V2.6-Pro

Introduce DeepSeek-V4.1-Flash, a multimodal Mixture-of-Experts (MoE) model with 552B backbone parameters and support for contexts of up to one million tokens.

DeepSeek-V4.1-Flash

GLM-5.3 is a large-scale reasoning model from Z.ai, built for complex software engineering and long-horizon agent tasks. It supports text input and output with a 1M-token context window, and improves on GLM-5.2 in coding and in the balance between performance and token efficiency.

GLM-5.3

GLM-5.3-Flash is a native multimodal model from Z.ai. It is suited for efficient coding and long-horizon agent tasks. Its hybrid sparse and linear attention architecture maintains accurate long-context behavior while reducing compute overhead.

GLM-5.3-Flash

Kimi K3 is Moonshot AI's 2.8T-parameter open-weight multimodal reasoning model. Built for complex coding, knowledge work, and long-horizon agentic workflows, it excels at navigating large repositories, calling tools, debugging, and iterating on images, logs, tests, and runtime feedback. Its architecture relies on KDA and Attention Residuals for computational efficiency.

Kimi-K3

DeepSeek-V4-Pro-0813 is the official release of DeepSeek-V4-Pro, superseding the preview version, with greatly enhanced agentic capabilities and performance improvements that are especially pronounced in production environments. It is built on the DeepSeek-V4-Pro (Preview) model structure, with a DSpark speculative decoding module attached.

DeepSeek-V4-Pro-0813

DeepSeek-V4-Flash-0731 is the official release of DeepSeek-V4-Flash, superseding the preview version, with substantially enhanced agentic capabilities. DeepSeek-V4-Flash-0731 outperforms DeepSeek-V4-Pro (Preview) on benchmarks listed below despite its far smaller activated parameter count, and is broadly competitive with the strongest proprietary models available.

DeepSeek-V4-Flash-0731

GLM-5.2 is Z-AI's latest flagship model for long-horizon tasks. It marks a substantial leap in long-horizon task capability over its predecessor GLM-5.1 and, for the first time, delivers that capability on a **solid 1M-token context**.

GLM-5.2

Nemotron 3 Ultra is built for, frontier reasoning, orchestration, coding agents, deep research, and complex enterprise workflows. It delivers up to 5x faster inference and up to 30% lower cost for agentic workloads while supporting up to 1M token context.

NVIDIA-Nemotron-3-Ultra-550B-A55B

DeepSeek V4 Flash is an efficiency-focused MoE model with 284B total parameters (13B active) and a 1M-token context window. It's tuned for fast inference and high-throughput use cases while still holding up on reasoning and coding tasks.

DeepSeek-V4-Flash

DeepSeek V4 Pro is an MoE model with 1.6T total parameters (49B active) and a 1M-token context window. It's built for advanced reasoning, coding, and long-running agent tasks, and performs well on knowledge, math, and software engineering benchmarks.

DeepSeek-V4-Pro

Kimi K2.6 is an open-source, native multimodal agentic model that advances practical capabilities in long-horizon coding, coding-driven design, proactive autonomous execution, and swarm-based task orchestration.

Kimi-K2.6

Qwen3.6-35B-A3B is Alibaba's latest flagship Mixture-of-Experts model, with 35B total parameters and only 3B activated per token (256 experts, 8 routed + 1 shared). Built on direct feedback from the community, Qwen3.6 prioritizes stability and real-world utility, offering developers a more intuitive, responsive, and genuinely productive coding experience.

Qwen3.6-35B-A3B

Qwen3.5-397B-A17B is Alibaba's most capable Qwen3.5 model, a Mixture-of-Experts architecture with 397B total parameters and 17B activated per token. It features a 262K token context window (extensible to 1M with YaRN), thinking/reasoning mode, tool calling with MCP integration, and support for 201 languages. Sets state-of-the-art results on reasoning, coding, math, and multimodal benchmarks.

Qwen3.5-397B-A17B

Efficient, MoE variant of Gemma 4. Gemma is a family of open models built by Google DeepMind. Gemma 4 models are multimodal, handling text and image input and generating text output.

gemma-4-26B-A4B-it

Gemma is a family of open models built by Google DeepMind. Gemma 4 models are multimodal, handling text and image input and generating text output.

gemma-4-31B-it

NVIDIA Nemotron 3 Super is a hybrid Mixture-of-Experts (MoE) model engineered for highest compute efficiency and accuracy in multi-agent applications and specialized agentic systems. It is optimized to run many collaborating agents per application on a single GPU, delivering high accuracy for reasoning, tool use, and instruction following.

NVIDIA-Nemotron-3-Super-120B-A12B

  Qwen3-TTS is an advanced text-to-speech model by Alibaba's Qwen team, delivering stable, expressive, and low-latency speech generation across 10 languages.                                                                                                                                                                                                                                                                                                                                           Key capabilities:                                                                                                                                                                                                                                  - 9 preset voices — Vivian, Serena, Uncle_Fu, Dylan, Eric, Ryan, Aiden, Ono_Anna, Sohee — covering diverse genders, ages, and accents                                                                                                              - Voice cloning — clone any voice from a short (~3s) audio sample via the voice_id parameter   - Instruction control — adjust tone, emotion, and speaking style with natural language (e.g. "speak slowly and calmly", "excited tone")   - 10 languages — English, Chinese, Japanese, Korean, German, French, Russian, Spanish, Italian, Portuguese   - Streaming support — real-time PCM streaming with ~97ms first-byte latency   - Multiple output formats — WAV, MP3, FLAC, PCM    Built on a 1.7B parameter architecture using discrete multi-codebook language modeling for end-to-end speech synthesis without cascading errors. Uses a custom 12Hz acoustic tokenizer that preserves paralinguistic information and   environmental audio details.

Qwen3-TTS

● Qwen3-TTS-VoiceDesign is a voice design variant of Qwen3-TTS by Alibaba's Qwen team. Instead of selecting from preset voices, you describe the voice you want in natural language — and the model generates speech in that voice.                                                                                                                                                                                                                                                                     Key capabilities:                                                                                                                                                                                                                                  - Natural language voice control — describe any voice with free text (e.g. "a deep male voice with a calm, authoritative presence", "a young cheerful female with a warm and friendly tone")   - 10 languages — English, Chinese, Japanese, Korean, German, French, Russian, Spanish, Italian, Portuguese                                                                                                                                         - Streaming support — real-time PCM streaming   - Multiple output formats — WAV, MP3, FLAC, PCM    Built on the same 1.7B parameter architecture as Qwen3-TTS, using discrete multi-codebook language modeling and a custom 12Hz acoustic tokenizer for high-quality end-to-end speech synthesis.

Qwen3-TTS-VoiceDesign

DeepSeek-V3.2 is a large language model designed to harmonize high computational efficiency with strong reasoning and agentic tool-use performance. It introduces DeepSeek Sparse Attention (DSA), a fine-grained sparse attention mechanism that reduces training and inference cost while preserving quality in long-context scenarios. A scalable reinforcement learning post-training framework further improves reasoning, with reported performance in the GPT-5 class, and the model has demonstrated gold-medal results on the 2025 IMO and IOI. V3.2 also uses a large-scale agentic task synthesis pipeline to better integrate reasoning into tool-use settings, boosting compliance and generalization in interactive environments.

DeepSeek-V3.2

The fastest model of the Flux 2 family. Frontier visual intelligence — state-of-the-art image generation and editing from Black Forest Labs

FLUX-2-klein-4b

The best quality-to-latency ratio, production apps model of the Flux 2 family. Frontier visual intelligence — state-of-the-art image generation and editing from Black Forest Labs

FLUX-2-klein-9b

claude

Claude

deepseek

DeepSeek

flux

Flux

gemini

Gemini

kimi

Kimi

llama

Llama

mistral

Mistral

nemotron

Nemotron

qwen

Qwen

Nemotron Speech Streaming EN 0.6B is NVIDIA's 600M-parameter cache-aware FastConformer-RNNT model for low-latency English speech recognition. It transcribes audio as it arrives, with native punctuation and capitalization, by reusing cached encoder context instead of recomputing overlapping windows. DeepInfra serves it at 560 ms lookahead over a realtime WebSocket API compatible with OpenAI Realtime transcription, batching many concurrent streams on each GPU, for live captioning, voice agents and real-time speech-to-text.

`nvidia/Nemo3-ASR-Streaming` is served over realtime WebSocket sessions, compatible with OpenAI's Realtime transcription API: you stream audio in and receive the transcript as the words are recognized. It is not available over HTTP inference.

# Connect

```
wss://api.deepinfra.com/v1/realtime?model=nvidia/Nemo3-ASR-Streaming
```

Authenticate with `Authorization: Bearer $DEEPINFRA_API_KEY`. Browsers, which cannot set headers on a WebSocket, can pass the key as the subprotocol `openai-insecure-api-key.<key>` instead.

# Client events

- **session.update**: sets the input audio format. Send it first. Audio is 16-bit little-endian mono PCM at any sample rate (it is resampled on our side); the default is 24000 Hz.
- **input_audio_buffer.append**: a base64-encoded chunk of PCM audio. Send audio in real time, for example 100 ms per message; more than 10 s of audio waiting to be transcribed ends the session.
- **session.close**: transcribes any open utterance and ends the session.

# Server events

- **session.created**, **session.updated**: the session is ready, and the format you set.
- **conversation.item.input_audio_transcription.delta**: partial text as it is recognized. `delta` is the new text; `transcript` is the whole open utterance so far, which may revise earlier words.
- **conversation.item.input_audio_transcription.completed**: the final `transcript` of an utterance.
- **error**: `error.code` says what went wrong. The session then closes with a standard WebSocket close code: 1013 means try again later (for example `server_is_overloaded` or `websocket_connection_limit_reached`), 1012 and 1014 mean reconnect, and 1008, 3000 and 3003 will fail again until the request or the account changes.

Usage is billed per second of audio sent.

### Example

```python
import asyncio
import base64
import json
import os
import wave

from websockets.asyncio.client import connect

URL = "wss://api.deepinfra.com/v1/realtime?model=nvidia/Nemo3-ASR-Streaming"
PACKET_SEC = 0.1


async def main() -> None:
    with wave.open("speech.wav") as w:  # 16-bit mono PCM
        rate, pcm = w.getframerate(), w.readframes(w.getnframes())
    packet = int(rate * PACKET_SEC) * 2
    headers = {"Authorization": "Bearer " + os.environ["DEEPINFRA_API_KEY"]}

    async with connect(URL, additional_headers=headers) as ws:
        await ws.send(json.dumps({"type": "session.update", "session": {
            "type": "transcription",
            "audio": {"input": {"format": {"type": "audio/pcm", "rate": rate}}}}}))

        async def send_audio() -> None:
            for off in range(0, len(pcm), packet):
                await ws.send(json.dumps({"type": "input_audio_buffer.append",
                                          "audio": base64.b64encode(pcm[off:off + packet]).decode()}))
                await asyncio.sleep(PACKET_SEC)
            await ws.send(json.dumps({"type": "session.close"}))

        sender = asyncio.create_task(send_audio())
        async for raw in ws:
            event = json.loads(raw)
            if event["type"] == "conversation.item.input_audio_transcription.delta":
                print("partial:", event.get("transcript") or event["delta"])
            elif event["type"] == "conversation.item.input_audio_transcription.completed":
                print("final:", event["transcript"])
            elif event["type"] == "error":
                print("error:", event["error"]["code"], event["error"]["message"])
        await sender


asyncio.run(main())
```

```
partial: Welcome to our AI
partial: Welcome to our AI testing session.
final: Welcome to our AI testing session.
```


`nvidia/Nemo3-ASR-Streaming` works with the OpenAI Python SDK's Realtime client (`pip install "openai[realtime]>=2"`). Point it at DeepInfra's OpenAI-compatible base URL and open a transcription session; partial and final transcripts arrive as events. See the Python tab for the full list of events and close codes.

### Example

```python
import asyncio
import base64
import os
import wave

from openai import AsyncOpenAI

MODEL = "nvidia/Nemo3-ASR-Streaming"
PACKET_SEC = 0.1


async def main() -> None:
    with wave.open("speech.wav") as w:  # 16-bit mono PCM
        rate, pcm = w.getframerate(), w.readframes(w.getnframes())
    packet = int(rate * PACKET_SEC) * 2

    client = AsyncOpenAI(
        api_key=os.environ["DEEPINFRA_API_KEY"],
        base_url="https://api.deepinfra.com/v1/openai",
        websocket_base_url="wss://api.deepinfra.com/v1/openai",
    )
    async with client.realtime.connect(model=MODEL) as conn:
        await conn.session.update(session={"type": "transcription", "audio": {"input": {
            "format": {"type": "audio/pcm", "rate": rate},
            "transcription": {"model": MODEL}}}})

        async def send_audio() -> None:
            for off in range(0, len(pcm), packet):
                await conn.input_audio_buffer.append(audio=base64.b64encode(pcm[off:off + packet]).decode())
                await asyncio.sleep(PACKET_SEC)
            # DeepInfra extension: transcribe the open utterance and end the session.
            await conn.send({"type": "session.close"})

        sender = asyncio.create_task(send_audio())
        async for event in conn:
            if event.type == "conversation.item.input_audio_transcription.delta":
                print("partial:", event.delta)
            elif event.type == "conversation.item.input_audio_transcription.completed":
                print("final:", event.transcript)
            elif event.type == "error":
                print("error:", event.error.code, event.error.message)
        await sender


asyncio.run(main())
```


Live captions from the microphone in the browser. A browser cannot set headers on a WebSocket, so the key goes in the `openai-insecure-api-key.<key>` subprotocol. Do not ship a long-lived API key to a browser: create a short-lived token limited to this model on your server with [`POST /v1/scoped-jwt`](https://docs.deepinfra.com/account/authentication) and pass that instead. A subprotocol cannot contain `:`, so send the returned `jwt:<token>` as `jwt.<token>`, as below. See the Python tab for the full list of events and close codes.

### Example

```javascript
const MODEL = "nvidia/Nemo3-ASR-Streaming";

// token: the `jwt:<token>` returned by POST /v1/scoped-jwt
async function startCaptions(token, onPartial, onFinal) {
  const audio = new AudioContext();
  const mic = await navigator.mediaDevices.getUserMedia({ audio: true });

  // Converts the microphone's float samples to 16-bit PCM, 100 ms per message.
  const worklet = `registerProcessor("pcm", class extends AudioWorkletProcessor {
    constructor() { super(); this.buf = []; }
    process([input]) {
      for (const s of input[0] ?? []) this.buf.push(Math.max(-1, Math.min(1, s)) * 0x7fff);
      if (this.buf.length >= sampleRate / 10) {
        this.port.postMessage(Int16Array.from(this.buf).buffer);
        this.buf = [];
      }
      return true;
    }
  });`;
  await audio.audioWorklet.addModule(URL.createObjectURL(new Blob([worklet], { type: "text/javascript" })));
  const node = new AudioWorkletNode(audio, "pcm");
  audio.createMediaStreamSource(mic).connect(node);

  const ws = new WebSocket(
    `wss://api.deepinfra.com/v1/realtime?model=${MODEL}`,
    ["realtime", `openai-insecure-api-key.${token.replace(/^jwt:/, "jwt.")}`],
  );
  ws.onopen = () => {
    ws.send(JSON.stringify({
      type: "session.update",
      session: { type: "transcription", audio: { input: { format: { type: "audio/pcm", rate: audio.sampleRate } } } },
    }));
    node.port.onmessage = ({ data }) => {
      const b64 = btoa(String.fromCharCode(...new Uint8Array(data)));
      ws.send(JSON.stringify({ type: "input_audio_buffer.append", audio: b64 }));
    };
  };
  ws.onmessage = ({ data }) => {
    const event = JSON.parse(data);
    if (event.type === "conversation.item.input_audio_transcription.delta") {
      onPartial(event.transcript ?? event.delta);
    } else if (event.type === "conversation.item.input_audio_transcription.completed") {
      onFinal(event.transcript);
    } else if (event.type === "error") {
      console.error(event.error.code, event.error.message);
    }
  };

  return () => {
    ws.send(JSON.stringify({ type: "session.close" }));
    mic.getTracks().forEach((t) => t.stop());
    audio.close();
  };
}
```


The service tier used for processing the request. 'priority' processes the request with higher priority (premium rate); 'flex' processes it at lower priority for a discount, served only when spare capacity exists and may be retried/timed out under load. Both apply only to models that support the respective tier. For compatibility, 'auto' is treated as 'priority' and 'standard_only' as 'default'.

service_tier

If true, the request is rejected immediately with HTTP 429 when the model has no spare capacity, instead of waiting in the queue. Opt-in; the default (false) keeps standard queueing behavior.

fail_fast

audio

task

optional text to provide as a prompt for the first window.

initial_prompt

temperature

language that the audio is in; uses detected language if None; use two-letter language code (ISO 639-1) (e.g. en, de, ja)

language

chunk_level

chunk_length_s

The webhook to call when inference is done, by default you will get the output in the response of your inference request

webhook

ServiceTier

Audio

Chunk Length S

Chunk Level

Fail Fast

Initial Prompt

Language

Task

Temperature

Webhook

AutomaticSpeechRecognitionIn

estimated cost billed for the request in USD

Cost

Output Length

Runtime Ms

Status

Tokens Generated

Tokens Input

InferenceReplyStatus

Avg Logprob

Compression Ratio

confidence of the segment (Only in whisper-timestamped model)

Confidence

end location in input in seconds from start

No Speech Prob

Seek

start location in input in seconds from start

Start

Text

Tokens

Segment

Word

Duration

Object containing the status of the inference request

Input Length Ms

Request Id

Segments

a list of timestamped words in a segment (Only in whisper-timestamped model)

Words

AutomaticSpeechRecognitionOut

model

file

An optional text to guide the model's style or continue a previous audio segment.

prompt

An instruction that replaces the model's default transcription instruction (instruction-following models only); prompt is then added as context terms.

instruction

The format of the output; diarized_json adds a speaker to every segment (speaker-aware models only)

response_format

The sampling temperature, between 0 and 1. Higher values produce more creative results.

An array specifying the granularity of timestamps to include in the transcription. Possible values are 'segment', 'word'.