TL;DR
O Qwen 3.6 Plus Preview foi lançado em 30 de março de 2026, com uma janela de contexto de 1 milhão de tokens, raciocínio obrigatório (chain-of-thought) e suporte a uso de ferramentas. Ele está completamente gratuito no OpenRouter agora. Use o ID do modelo qwen/qwen3.6-plus-preview:free com qualquer cliente compatível com OpenAI para começar a enviar requisições hoje.
O modelo que apareceu discretamente
A Alibaba Cloud lançou o Qwen 3.6 Plus Preview em 30 de março de 2026. Nenhum anúncio chamativo. Nenhuma lista de espera. Apenas um novo modelo disponível no OpenRouter a $0 por milhão de tokens.
Nos seus primeiros dois dias, processou mais de 400 milhões de tokens de conclusão em aproximadamente 400.000 requisições. Desenvolvedores o consideraram rápido.
Este artigo o guiará por tudo o que você precisa para começar: configuração de conta, chaves de API, exemplos de código em cURL, Python e Node.js, e conselhos específicos sobre onde este modelo tem o melhor desempenho.
Ao final deste guia, você saberá exatamente como chamar o Qwen 3.6 gratuitamente, do que ele é capaz e onde ele falha.
O que o Qwen 3.6 adiciona sobre a série 3.5
O salto de 3.5 para 3.6 não é incremental. Três coisas mudaram de forma significativa.
1. A janela de contexto cresceu para 1 milhão de tokens
O Qwen 3.5 tinha uma janela de contexto de 32K a 128K, dependendo da variante. O Qwen 3.6 suporta 1 milhão de tokens de entrada.
Para colocar isso em termos práticos: 1 milhão de tokens equivale a aproximadamente 750.000 palavras. Isso é o suficiente para alimentar o modelo com uma base de código inteira, um ano de logs do Slack, uma biblioteca completa de documentos legais ou um grande corpus de pesquisa em uma única requisição.
A maioria dos modelos gratuitos atinge no máximo 8K a 32K. Obter 1M de tokens gratuitamente é incomum.
2. O raciocínio é integrado, não opcional
O Qwen 3.6 usa tokens de raciocínio obrigatórios (chain-of-thought). Antes que o modelo produza sua resposta final, ele gera uma cadeia de pensamento interna. Você não precisa instruí-lo com "pense passo a passo" ou qualquer instrução especial.
Este é o mesmo padrão que o DeepSeek R1 popularizou. A diferença é que o Qwen 3.6 o aplica em tarefas de codificação, front-end e resolução geral de problemas, não apenas em matemática.
3. O comportamento de agente é mais confiável
A chamada de ferramentas na série 3.5 era inconsistente. As funções eram chamadas com tipos de argumentos errados, ou o modelo alucinava uma chamada de função que não existia.
O Qwen 3.6 aborda isso diretamente. De acordo com a descrição da própria Alibaba Cloud, ele "oferece um raciocínio mais forte e um comportamento de agente mais confiável em comparação com a série 3.5". Na prática, isso significa menos chamadas de ferramentas quebradas em fluxos de trabalho de várias etapas.
O modelo é especificamente ajustado para três tarefas:
- Codificação de agente (geração de código em várias etapas com uso de ferramentas)
- Desenvolvimento front-end (geração de componentes HTML, CSS, JavaScript)
- Resolução de problemas complexos (pesquisa, análise, resumo de contexto longo)
Como acessar o Qwen 3.6 gratuitamente
Você precisa de duas coisas: uma conta OpenRouter e uma chave de API. Não é necessário cartão de crédito para modelos gratuitos.
Passo 1: Crie sua conta OpenRouter
Vá para openrouter.ai e cadastre-se com e-mail ou uma conta Google. Todo o processo leva menos de dois minutos.
Modelos gratuitos não exigem que você adicione um método de pagamento. Você obtém acesso imediatamente após a verificação do e-mail.
Passo 2: Gere uma chave de API
- Clique no seu avatar de perfil no canto superior direito
- Selecione **Chaves de API** no menu suspenso
- Clique em **Criar Chave**
- Dê um nome (por exemplo,
qwen-test) e clique em **Criar** - Copie a chave. Ela começa com
sk-or-v1-...
Armazene isso em um local seguro. O OpenRouter não mostrará novamente.
Passo 3: Envie sua primeira requisição
O ID do modelo é qwen/qwen3.6-plus-preview:free.
O OpenRouter usa o mesmo formato de requisição da API OpenAI, então qualquer cliente compatível com OpenAI funciona sem modificações.
cURL:
curl https://openrouter.ai/api/v1/chat/completions \
-H "Authorization: Bearer sk-or-v1-SUA_CHAVE_AQUI" \
-H "Content-Type: application/json" \
-d '{
"model": "qwen/qwen3.6-plus-preview:free",
"messages": [
{
"role": "user",
"content": "Escreva uma função Python que analisa um token JWT e retorna o payload como um dicionário."
}
]
}'
Python (biblioteca requests):
import requests
def call_qwen(prompt: str, api_key: str) -> str:
response = requests.post(
"https://openrouter.ai/api/v1/chat/completions",
headers={
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json",
},
json={
"model": "qwen/qwen3.6-plus-preview:free",
"messages": [{"role": "user", "content": prompt}],
},
timeout=60,
)
response.raise_for_status()
return response.json()["choices"][0]["message"]["content"]
result = call_qwen(
"Escreva uma função Python que analisa um token JWT e retorna o payload.",
api_key="sk-or-v1-SUA_CHAVE_AQUI"
)
print(result)
Node.js (fetch):
async function callQwen(prompt, apiKey) {
const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
method: "POST",
headers: {
"Authorization": `Bearer ${apiKey}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
model: "qwen/qwen3.6-plus-preview:free",
messages: [{ role: "user", content: prompt }],
}),
});
if (!response.ok) {
throw new Error(`Erro do OpenRouter: ${response.status} ${await response.text()}`);
}
const data = await response.json();
return data.choices[0].message.content;
}
callQwen(
"Escreva uma função JavaScript que valida um endereço de e-mail.",
"sk-or-v1-SUA_CHAVE_AQUI"
).then(console.log);
Python com o SDK da OpenAI:
Se você já usa o SDK Python da OpenAI, pode apontá-lo para o OpenRouter sem outras alterações:
from openai import OpenAI
client = OpenAI(
base_url="https://openrouter.ai/api/v1",
api_key="sk-or-v1-SUA_CHAVE_AQUI",
)
response = client.chat.completions.create(
model="qwen/qwen3.6-plus-preview:free",
messages=[
{
"role": "system",
"content": "Você é um engenheiro de backend sênior. Escreva um código limpo e pronto para produção."
},
{
"role": "user",
"content": "Escreva uma função Python que tenta novamente uma requisição HTTP falha até 3 vezes com um backoff exponencial."
}
],
)
print(response.choices[0].message.content)
Uso de ferramentas e fluxos de trabalho de agente
O uso de ferramentas é onde o Qwen 3.6 se destaca na camada gratuita. Aqui está um exemplo funcional:
from openai import OpenAI
import json
client = OpenAI(
base_url="https://openrouter.ai/api/v1",
api_key="sk-or-v1-SUA_CHAVE_AQUI",
)
# Defina as ferramentas disponíveis para o modelo
tools = [
{
"type": "function",
"function": {
"name": "search_api_docs",
"description": "Pesquise a documentação da API por um endpoint ou parâmetro específico",
"parameters": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "A consulta de pesquisa"
},
"version": {
"type": "string",
"enum": ["v1", "v2", "v3"],
"description": "Versão da API a ser pesquisada"
}
},
"required": ["query"]
}
}
},
{
"type": "function",
"function": {
"name": "run_api_test",
"description": "Execute uma requisição de teste contra um endpoint da API",
"parameters": {
"type": "object",
"properties": {
"endpoint": {"type": "string"},
"method": {"type": "string", "enum": ["GET", "POST", "PUT", "DELETE"]},
"body": {"type": "object"}
},
"required": ["endpoint", "method"]
}
}
}
]
messages = [
{
"role": "user",
"content": "Encontre a documentação para o endpoint /users e execute uma requisição GET de teste contra ele."
}
]
response = client.chat.completions.create(
model="qwen/qwen3.6-plus-preview:free",
messages=messages,
tools=tools,
tool_choice="auto",
)
message = response.choices[0].message
# Verifique se o modelo deseja chamar uma ferramenta
if message.tool_calls:
for tool_call in message.tool_calls:
print(f"Ferramenta: {tool_call.function.name}")
args = json.loads(tool_call.function.arguments)
print(f"Argumentos: {json.dumps(args, indent=2)}")
else:
print(message.content)
O modelo irá gerar uma chamada de função estruturada em vez de alucinar uma resposta de forma livre. Você então executa a função em seu próprio código e alimenta o resultado de volta na próxima rodada.
É assim que os fluxos de trabalho de agente em várias etapas são construídos: o modelo chama ferramentas, seu código as executa e você repete até que a tarefa seja concluída.
Usando a janela de contexto de 1 milhão de tokens
Um contexto de 1M de tokens não é útil para perguntas simples. Ele foi projetado para tarefas onde você precisa fornecer ao modelo uma grande quantidade de contexto de uma só vez.
Aqui estão três padrões onde isso realmente importa:
Revisão completa da base de código
Alimente o modelo com sua base de código inteira (dentro do limite de tokens) e peça para identificar problemas de segurança, padrões inconsistentes ou funções não documentadas.
import os
from pathlib import Path
from openai import OpenAI
client = OpenAI(
base_url="https://openrouter.ai/api/v1",
api_key="sk-or-v1-SUA_CHAVE_AQUI",
)
def load_codebase(directory: str, extensions: list[str]) -> str:
"""Carrega todos os arquivos-fonte de um diretório para uma única string."""
content_parts = []
for path in Path(directory).rglob("*"):
if path.suffix in extensions and path.is_file():
try:
text = path.read_text(encoding="utf-8", errors="ignore")
content_parts.append(f"--- ARQUIVO: {path} ---\n{text}\n")
except Exception:
continue
return "\n".join(content_parts)
codebase = load_codebase("./src", [".py", ".js", ".ts"])
response = client.chat.completions.create(
model="qwen/qwen3.6-plus-preview:free",
messages=[
{
"role": "user",
"content": f"Revise esta base de código e identifique:\n1. Vulnerabilidades de segurança\n2. Funções sem tratamento de erros\n3. Convenções de nomenclatura inconsistentes\n\nBase de Código:\n{codebase}"
}
],
)
print(response.choices[0].message.content)
Análise de documentos grandes
Passe um longo documento legal, relatório financeiro ou artigo de pesquisa e faça perguntas específicas sobre ele.
with open("annual_report_2025.txt", "r") as f:
document = f.read()
response = client.chat.completions.create(
model="qwen/qwen3.6-plus-preview:free",
messages=[
{
"role": "user",
"content": f"Extraia todas as menções de limites de taxa de API e mudanças de preço deste documento:\n\n{document}"
}
],
)
Conversa multi-turno com histórico completo
Mantenha o histórico completo da conversa em contexto sem truncamento, útil para longas sessões de depuração ou entrevistas técnicas.
conversation = []
def chat(user_message: str) -> str:
conversation.append({"role": "user", "content": user_message})
response = client.chat.completions.create(
model="qwen/qwen3.6-plus-preview:free",
messages=conversation,
)
assistant_message = response.choices[0].message.content
conversation.append({"role": "assistant", "content": assistant_message})
return assistant_message
# Longa sessão de depuração de ida e volta
print(chat("Estou recebendo um erro 401 da API do GitHub. Aqui está meu código..."))
print(chat("Adicionei o token, mas agora recebo um 403. O token tem escopo de repositório."))
print(chat("O repositório é privado. Quais escopos eu realmente preciso?"))
Testando requisições da API OpenRouter com Apidog
Ao desenvolver sobre a API OpenRouter, depurar requisições falhas torna-se rapidamente tedioso. Você está fazendo requisições HTTP, verificando respostas JSON e iterando seus prompts. Fazer isso pela linha de comando ou Postman é lento.
Apidog vale a pena experimentar aqui. É um cliente de API gratuito que lida com a construção de requisições, inspeção de respostas e automação de testes em um só lugar.
Para testar o endpoint do Qwen 3.6 no Apidog:
- Crie uma nova requisição POST para
https://openrouter.ai/api/v1/chat/completions - Adicione seu cabeçalho
Authorization: Bearer sk-or-v1-... - Defina o corpo como JSON com seus campos
modelemessages - Envie a requisição e inspecione a resposta
Você pode salvar isso como uma coleção, alternar entre IDs de modelo para comparar saídas e escrever testes automatizados que verificam a estrutura da resposta, verificam se choices[0].message.content não está vazio ou afirmam que as chamadas de ferramentas contêm o nome da função esperado.
Se você está construindo um aplicativo que chama o OpenRouter, escrever alguns testes de requisição no Apidog desde o início economiza tempo quando o modelo se comporta inesperadamente.
Limites da camada gratuita a serem conhecidos antes de desenvolver com isso
O Qwen 3.6 é gratuito agora. Isso não durará indefinidamente, e há restrições práticas a serem consideradas.
Limites de taxa são compartilhados. Modelos gratuitos no OpenRouter compartilham capacidade entre todos os usuários. Durante os horários de pico (noite nos EUA, tipicamente), você verá maior latência e erros ocasionais de limite de taxa. Incorpore lógica de repetição em qualquer código de produção.
import time
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
session = requests.Session()
retry_strategy = Retry(
total=3,
backoff_factor=2,
status_forcelist=[429, 500, 502, 503, 504],
)
adapter = HTTPAdapter(max_retries=retry_strategy)
session.mount("https://", adapter)
response = session.post(
"https://openrouter.ai/api/v1/chat/completions",
headers={"Authorization": "Bearer sk-or-v1-SUA_CHAVE_AQUI"},
json={
"model": "qwen/qwen3.6-plus-preview:free",
"messages": [{"role": "user", "content": "Olá"}],
},
timeout=30,
)
Os dados são registrados. A página do modelo do OpenRouter afirma que "o modelo coleta dados de prompt e conclusão que podem ser usados para melhorar o modelo". Não envie chaves de API, senhas ou informações de identificação pessoal por meio deste endpoint.
Status de pré-visualização. Esta é uma versão de pré-visualização. O comportamento do modelo pode mudar. Se você estiver usando-o para inferência em produção, fixe seus testes de integração ao ID do modelo atual e monitore por regressões.
Apenas texto. O Qwen 3.6 aceita entrada de texto e produz saída de texto. Sem imagens, sem áudio, sem uploads de arquivos.
Casos de uso do mundo real
Construindo um agente de revisão de código. Uma equipe construindo uma ferramenta interna de revisão de PRs alimentou seus diffs de pull request inteiros (às vezes mais de 10 mil linhas) no Qwen 3.6 e obteve feedback detalhado sobre erros de lógica, testes ausentes e problemas de segurança. A janela de 1M de tokens tornou isso possível sem segmentação.
Geração de componentes front-end. Um desenvolvedor solo construindo um painel SaaS usou o Qwen 3.6 para gerar componentes React a partir de especificações de design. O modelo produziu TypeScript limpo com tipos de propriedades adequados e CSS responsivo sem a necessidade de várias passagens de correção.
Resumo da documentação da API. Uma equipe migrando entre APIs de pagamento de terceiros passou a documentação completa para ambas as APIs (cada uma com cerca de 100K tokens) em uma única requisição e pediu uma comparação lado a lado dos métodos de autenticação, formatos de webhook e limites de taxa. O modelo retornou uma tabela estruturada em menos de 30 segundos.
Cadastre-se em openrouter.ai, pegue sua chave e substitua por qwen/qwen3.6-plus-preview:free para qualquer modelo pelo qual você esteja pagando atualmente.
Perguntas Frequentes
O Qwen 3.6 é realmente gratuito para usar?
Sim. Em março de 2026, o modelo está listado a $0 por milhão de tokens de entrada e $0 por milhão de tokens de saída no OpenRouter. O status gratuito pode mudar quando o período de pré-visualização terminar, então verifique a página de preços do OpenRouter antes de construir algo que dependa do custo permanecer zero.
Qual é o limite de taxa para a camada gratuita?
O OpenRouter não publica limites de taxa exatos para modelos da camada gratuita. Na prática, modelos gratuitos compartilham capacidade e estão sujeitos a estrangulamento durante alto tráfego. Comece com uma requisição por vez e adicione lógica de repetição antes de aumentar a concorrência.
Posso usar o Qwen 3.6 para projetos comerciais?
Sim, o OpenRouter permite o uso comercial. Verifique a licença do modelo Qwen da Alibaba Cloud para quaisquer restrições sobre o próprio modelo subjacente, particularmente se você estiver distribuindo as saídas.
Por que o Qwen 3.6 demora mais para responder do que outros modelos?
Os tokens de raciocínio obrigatórios adicionam latência. Antes de gerar uma resposta, o modelo trabalha por meio de uma cadeia de pensamento interna. Para prompts simples, isso pode adicionar alguns segundos. Para tarefas complexas de raciocínio, a latência extra vale a pena. Use o streaming se quiser mostrar a saída parcial conforme ela é gerada.
Existe uma maneira de desativar os tokens de raciocínio?
A partir da pré-visualização atual, o raciocínio é obrigatório e não pode ser desativado. Se você precisar de respostas mais rápidas sem cadeia de pensamento, experimente uma variante de modelo diferente quando uma estiver disponível, ou use um modelo gratuito menor como o LLaMA 3.1 8B para tarefas sensíveis à latência.
Como a janela de contexto de 1M de tokens afeta o custo?
Na camada gratuita, não afeta. Você paga $0, independentemente de quantos tokens você enviar. Tenha em mente que requisições muito grandes demoram mais para serem processadas e podem expirar na camada gratuita. Comece com um tempo limite de 30 a 60 segundos e aumente-o para requisições acima de 100K tokens.