> ## Documentation Index
> Fetch the complete documentation index at: https://docs.aieev.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Qwen3-32B

> Dense 32B model with hybrid reasoning for general-purpose text tasks.

<Info>
  **Model ID:** `qwen/qwen3-32b` | **Endpoint ID:** `qwen3-32b` | **Parameters:** 32B | **Released:** 2025-04-29
</Info>

|  Input Price | Output Price | Context |   Modality  |
| :----------: | :----------: | :-----: | :---------: |
| \$0.080 / 1M | \$0.280 / 1M |  40,960 | text → text |

## Overview

Qwen3-32B is a 32B-parameter dense model from the Qwen3 generation. It supports hybrid reasoning (thinking mode), working through complex problems step by step before answering while responding quickly for everyday conversation. The model shows strong multilingual understanding and generation, along with solid coding and math capabilities. It supports a context window of up to 40,960 tokens.

<CardGroup cols={3}>
  <Card title="Air API Playground" icon="play" href="https://ap-1.aieev.cloud:3007/models/qwen%2Fqwen3-32b">
    Try the model in the playground.
  </Card>

  <Card title="Deploy with Container" icon="container-storage" href="/docs/air-container/deploy-a-container">
    Deploy with AIR Container.
  </Card>

  <Card title="OpenAI Compatible API" icon="arrow-left-right" href="/docs/air-api/openai-compatible-api">
    Connect with the OpenAI SDK as-is.
  </Card>
</CardGroup>

## Pricing

| Currency | Input (1M tokens) | Output (1M tokens) |
| :------- | ----------------: | -----------------: |
| USD      |           \$0.080 |            \$0.280 |
| KRW      |              ₩120 |               ₩420 |

## Supported Features

All features are available through the [OpenAI Compatible API](/docs/air-api/openai-compatible-api).

| Feature                                                                           | Supported | Notes                                                                                                                            |
| :-------------------------------------------------------------------------------- | :-------: | :------------------------------------------------------------------------------------------------------------------------------- |
| [Streaming](/docs/air-api/openai-compatible-api#streaming)                        |     ✅     | SSE, `include_usage` supported                                                                                                   |
| [Tool Calling](/docs/air-api/openai-compatible-api#tool-calling-function-calling) |     ✅     | Parallel and streaming tool calls supported                                                                                      |
| [Vision](/docs/air-api/openai-compatible-api#vision-image-input)                  |     ❌     | Not supported                                                                                                                    |
| [Reasoning](/docs/air-api/openai-compatible-api#reasoning)                        |     ✅     | Reasoning arrives inline as `<think>` tags inside `content`, not in the `reasoning` field. Disable via `enable_thinking: false`. |
| [JSON Mode](/docs/air-api/openai-compatible-api#json-mode-structured-outputs)     |     ✅     | `response_format: json_object`                                                                                                   |
| logprobs                                                                          |     ✅     | `logprobs` / `top_logprobs`                                                                                                      |

## Key Features

* Stable, high-quality output from a 32B dense architecture
* Hybrid reasoning (thinking mode) that can be toggled on or off
* Strong multilingual, coding, and math performance
* Tool calling and JSON mode support for structured, agentic workflows

## Use Cases

### Complex Q\&A & Reasoning

Work through multi-step problems by reasoning before answering.

<CodeGroup>
  ```text Input theme={null}
  A train leaves station A at 60 km/h. Two hours later, a second train leaves the same station at 90 km/h in the same direction. How long does it take the second train to catch up?
  ```

  ```text Output theme={null}
  <think>
  The first train has a 2-hour head start, covering 120 km before the second
  train departs. The second train closes the gap at 90 - 60 = 30 km/h, so it
  needs 120 / 30 = 4 hours to catch up.
  </think>

  It takes the second train 4 hours to catch up.
  ```
</CodeGroup>

### Code Generation & Assistance

Generate and explain code for practical development tasks.

<CodeGroup>
  ```text Input theme={null}
  Write a Python function to check if a number is prime and explain the logic.
  ```

  ```python Output theme={null}
  def is_prime(n):
      if n <= 1:
          return False
      for i in range(2, int(n ** 0.5) + 1):
          if n % i == 0:
              return False
      return True

  # This function checks divisibility only up to the square root of n,
  # which improves efficiency.
  ```
</CodeGroup>

### Document Summarization

Summarize long documents and extract key points across multiple languages.

## Parameters

| Parameter            | Type             | Required | Default | Description                                                    |
| -------------------- | ---------------- | -------- | ------- | -------------------------------------------------------------- |
| `messages`           | array            | Required | -       | List of input messages for chat-based generation.              |
| `max_tokens`         | integer          | Optional | -       | Maximum output tokens to generate                              |
| `temperature`        | number           | Optional | 1       | Sampling temperature (0.0-2.0)                                 |
| `top_p`              | number           | Optional | 1       | Nucleus sampling threshold                                     |
| `top_k`              | integer          | Optional | -       | Limit sampling to the top-k most likely tokens                 |
| `min_p`              | number           | Optional | -       | Minimum probability threshold for token sampling               |
| `frequency_penalty`  | number           | Optional | 0       | Penalty for token frequency                                    |
| `presence_penalty`   | number           | Optional | 0       | Penalty for token presence                                     |
| `repetition_penalty` | number           | Optional | -       | Penalty for repeated token generation                          |
| `stop`               | string \| array  | Optional | -       | Stop sequence(s) that end generation                           |
| `seed`               | integer          | Optional | -       | Random seed for reproducible sampling                          |
| `stream`             | boolean          | Optional | false   | Enable streaming responses                                     |
| `tools`              | array            | Optional | -       | Tool calling function definitions                              |
| `tool_choice`        | string \| object | Optional | auto    | How tools are invoked (`auto`, `none`, or a specific function) |
| `response_format`    | object           | Optional | -       | JSON mode (`{"type": "json_object"}`)                          |
| `logprobs`           | boolean          | Optional | false   | Return per-token log probabilities                             |

## Model Details

| Property           | Value                                             |
| ------------------ | ------------------------------------------------- |
| Context Length     | 40,960                                            |
| Max Output Length  | 40,960                                            |
| Input Modalities   | text                                              |
| Output Modalities  | text                                              |
| Supported Features | tools, reasoning, streaming, json\_mode, logprobs |

## Quick Start

<Steps>
  <Step title="Get your API key">
    Generate an API key from your [AirCloud account](https://aieev.com).
  </Step>

  <Step title="Run the code">
    Replace `YOUR_API_KEY` with your actual key and choose your preferred language (Python, cURL, Node.js).
  </Step>
</Steps>

<CodeGroup>
  ```python Python theme={null}
  from openai import OpenAI

  client = OpenAI(
      api_key="YOUR_API_KEY",
      base_url="https://ap-1.aieev.cloud/endpoints/qwen3-32b/v1"
  )

  response = client.chat.completions.create(
      model="qwen/qwen3-32b",
      messages=[{"role": "user", "content": "Hello!"}]
  )

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

  ```bash cURL theme={null}
  curl https://ap-1.aieev.cloud/endpoints/qwen3-32b/v1/chat/completions \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "qwen/qwen3-32b",
      "messages": [{"role": "user", "content": "Hello!"}]
    }'
  ```

  ```javascript Node.js theme={null}
  import OpenAI from "openai";

  const client = new OpenAI({
    apiKey: "YOUR_API_KEY",
    baseURL: "https://ap-1.aieev.cloud/endpoints/qwen3-32b/v1",
  });

  const response = await client.chat.completions.create({
    model: "qwen/qwen3-32b",
    messages: [{ role: "user", content: "Hello!" }],
  });

  console.log(response.choices[0].message.content);
  ```
</CodeGroup>

## Tags

`open-source` `conversational` `32B` `reasoning` `multilingual`
