How to Use Qwen3.5 API for Free with NVIDIA ?

TL;DR

Qwen3.5 is Alibaba's groundbreaking 397-billion parameter vision-language model with Mixture of Experts (MoE) architecture. You can access it for free through NVIDIA's GPU-accelerated endpoints by registering for the NVIDIA Developer Program. This guide walks you through obtaining your API key, making your first calls, and integrating Qwen3.5's multimodal capabilities into your applications.

Try Apidog today

What is Qwen3.5 VLM?

Qwen3.5 is Alibaba's first native vision-language model in the Qwen3.5 series, designed specifically for building autonomous agents. Unlike previous VLMs that were adapted from text-only models, Qwen3.5 was built from the ground up for multimodal reasoning and UI navigation.

Key Specifications

Specification	Value
Total Parameters	397 billion
Active Parameters	17 billion
Activation Rate	4.28%
Expert Count	512 experts
Experts per Token	11 (10 routed + 1 shared)
Input Context	256K (extensible to 1M)
Languages Supported	200+
Architecture	MoE + Gated Delta Networks

What Makes Qwen3.5 Special

Mixture of Experts (MoE) architecture means only a subset of the model's parameters are active for any given input. This makes the model computationally efficient while maintaining the capacity for complex reasoning across all 397B parameters.

Native Multimodal Agent Capabilities set Qwen3.5 apart from other VLMs:

• Understands and navigates user interfaces
• Performs visual reasoning on mobile and web interfaces
• Handles complex coding tasks
• Powers chat applications with multimodal understanding

Ideal Use Cases

• Coding and Web Development: Write and debug code with visual context
• Visual Reasoning: Analyze screenshots, photos, and UI elements
• Chat Applications: Build conversational AI with multimodal understanding
• Complex Search: Search across images and text simultaneously
• UI Automation: Navigate and interact with interfaces autonomously

NVIDIA Developer Program: Get Your Free API Key

NVIDIA provides free access to Qwen3.5 through their GPU-accelerated endpoints. Here's how to get started:

Step 1: Join NVIDIA Developer Program

1. Visit build.nvidia.com
2. Click "Sign In" or "Create Account"
3. Register for the NVIDIA Developer Program (free)
4. Verify your email address

Step 2: Get Your API Key

1. After logging in, navigate to your account settings
2. Find "API Keys" or "NVIDIA API Key"
3. Copy your API key (starts with nvapi-)
4. Store it securely (you'll need it for authentication)

Pro Tip: Never expose your API key in client-side code. Use environment variables or a backend server to store it securely.

Step 3: Test Your Access

You can test Qwen3.5 directly in your browser at build.nvidia.com/qwen/qwen3.5-397b-a17b. This lets you experiment with prompts before writing any code.

Your First Qwen3.5 API Call

Here's how to make your first API call to Qwen3.5, complete with Python code:

import requests

# Configuration
invoke_url = "https://integrate.api.nvidia.com/v1/chat/completions"
api_key = os.getenv("NVIDIA_API_KEY")  # Best practice: use environment variables

headers = {
    "Authorization": f"Bearer {api_key}",
    "Accept": "application/json",
}

payload = {
    "messages": [
        {
            "role": "user",
            "content": "Explain Mixture of Experts architecture"
        }
    ],
    "model": "qwen/qwen3.5-397b-a17b",
    "max_tokens": 1024,
    "temperature": 0.7,
}

response = requests.post(invoke_url, headers=headers, json=payload)
print(response.json()['choices'][0]['message']['content'])

Making Multimodal Requests (With Images)

import base64
import os

def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode('utf-8')

image_base64 = encode_image("ui_screenshot.png")

payload = {
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/png;base64,{image_base64}"}
                },
                {
                    "type": "text",
                    "text": "Describe the UI elements in this screenshot"
                }
            ]
        }
    ],
    "model": "qwen/qwen3.5-397b-a17b",
    "max_tokens": 1024,
}

response = requests.post(invoke_url, headers=headers, json=payload)
print(response.json()['choices'][0]['message']['content'])

Complete Integration Examples

Python Client Class

class QwenClient:
    def __init__(self, api_key=None):
        self.api_key = api_key or os.getenv("NVIDIA_API_KEY")
        self.endpoint = "https://integrate.api.nvidia.com/v1/chat/completions"

    def chat(self, prompt, image_path=None, max_tokens=1024):
        headers = {"Authorization": f"Bearer {self.api_key}"}

        if image_path:
            # Multimodal request
            image_b64 = base64.b64encode(open(image_path, "rb").read()).decode()
            payload = {
                "messages": [{
                    "role": "user",
                    "content": [
                        {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_b64}"}},
                        {"type": "text", "text": prompt}
                    ]
                }],
                "model": "qwen/qwen3.5-397b-a17b",
                "max_tokens": max_tokens
            }
        else:
            # Text-only request
            payload = {
                "messages": [{"role": "user", "content": prompt}],
                "model": "qwen/qwen3.5-397b-a17b",
                "max_tokens": max_tokens
            }

        response = requests.post(self.endpoint, headers=headers, json=payload)
        return response.json()

JavaScript/Node.js Implementation

const axios = require('axios');
const fs = require('fs');

class QwenClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
  }

  async query(prompt, imagePath) {
    let messages = [{ role: 'user', content: prompt }];

    if (imagePath) {
      const imageData = fs.readFileSync(imagePath).toString('base64');
      messages[0].content = [
        { type: 'image_url', image_url: `data:image/png;base64,${imageData}` },
        { type: 'text', text: prompt }
      ];
    }

    const response = await axios.post(
      'https://integrate.api.nvidia.com/v1/chat/completions',
      {
        messages,
        model: 'qwen/qwen3.5-397b-a17b'
      },
      {
        headers: {
          'Authorization': `Bearer ${this.apiKey}`,
          'Content-Type': 'application/json'
        }
      }
    );

    return response.data;
  }
}

Advanced Features

Thinking Mode (Show Reasoning Steps)

payload = {
    "messages": [{
        "role": "user",
        "content": "Solve step-by-step: Train travels 120km in 2 hours, what's its speed?"
    }],
    "model": "qwen/qwen3.5-397b-a17b",
    "chat_template_kwargs": {"thinking": True}
}

Tool Calling (Agentic Workflows)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "parameters": {"type": "object", "properties": {"location": {"type": "string"}}}
        }
    }
]

response = requests.post(
    invoke_url,
    headers=headers,
    json={
        "messages": [{"role": "user", "content": "What's the weather in Berlin?"}],
        "model": "qwen/qwen3.5-397b-a17b",
        "tools": tools
    }
)

Deployment Options

Production with NVIDIA NIM

docker run --gpus all -p 8000:8000 \
  -e NVIDIA_API_KEY=$NVIDIA_API_KEY \
  nvcr.io/nim/qwen/qwen3.5-397b-a17b:latest

Your model will be available at http://localhost:8000 with the same API interface.

FAQ

Q: Is there really no cost?

A: Yes, NVIDIA's Developer Program currently provides free access to Qwen3.5 endpoints.

Q: How do I handle rate limits?

A: Monitor your usage in the NVIDIA developer dashboard. For commercial applications, consider NIM deployment.

Q: Can I fine-tune the model?

A: Yes, using NVIDIA's NeMo framework with LoRA support for efficient fine-tuning.

Pro Tip: For testing API integrations, try Apidog to validate responses and automate workflows.