qwenapis.comGuía
API Qwen3-Coder-Next: Una opción compatible con OpenAI
Este servicio no aloja un modelo llamado Qwen3-Coder-Next. Ofrece un único modelo general de pesos abiertos detrás de un endpoint compatible con OpenAI, y esta página indica cuándo conviene a un agente de código y cuándo no.
Actualizado:

La respuesta directa sobre qwen3-coder-next
Si escribiste qwen3-coder-next api en un buscador, probablemente quieras un endpoint al que puedas apuntar un agente de código. Sé claro sobre lo que es este sitio antes de continuar: es un proveedor independiente con un único modelo de pesos abiertos, ID uncensored, ajustado para responder sin rechazos de contenido para uso adulto lícito. No es la API oficial de Qwen3-Coder-Next ni de ningún modelo de Alibaba, y no enruta peticiones entre proveedores. Si tu plan depende de ese modelo exacto, su proveedor oficial o un host que lo liste por nombre es la opción correcta.
¿Entonces por qué escribir esta página? Porque muchas personas que buscan un modelo de código terminan necesitando la misma infraestructura: un endpoint de chat estilo OpenAI con llamadas a funciones, una ventana grande, límites de peticiones estables y un costo por token predecible. Esta API tiene eso. También no rechaza peticiones que otros asistentes declinan por razones de política, como escribir un escáner de puertos para tu propia red, discutir mecánicas de exploits para un ejercicio de laboratorio, o generar datos de prueba con lenguaje crudo. Todo se mantiene dentro del uso lícito, y hay un límite estricto: no hay contenido sexual que involucre menores de edad.
Lo que sigue es una comparación clara y un patrón probado para ejecutar un bucle de agente contra https://api.qwenapis.com/v1. Esta página no da números de benchmarking, porque no se conocen aquí, y no deberías confiar en las puntuaciones de codificación de nadie por encima de tu propio repositorio.
Lo que un agente de código pide a una API
Aparta los nombres de producto y un agente de código necesita seis cosas de su endpoint de modelo. Aquí te decimos cómo responde este servicio a cada una.
| Necesidad | Lo que esta API proporciona |
|---|---|
| Llamadas a funciones para herramientas de lectura, edición y ejecución | Sí: tools, tool_choice, llamadas tool_calls transmitidas, resultados como role: "tool" |
| Salida estructurada para planes y diffs | Modo JSON vía response_format |
| Espacio para archivos grandes e historiales largos | 100.000 tokens, prompt más completación |
| Streaming para editores en vivo | SSE con uso al final |
| Ejecuciones repetibles | seed, temperature, top_p, stop y las penalizaciones se pasan a través |
| Sub-agentes paralelos | 8 peticiones simultáneas, 300 por minuto con una clave completa |
Igual de importante es lo que falta. No hay embeddings, así que la búsqueda de código sobre un índice vectorial necesita una fuente de embeddings separada. No hay ajuste fino ni entrada o salida de imágenes. La lista de modelos tiene una sola entrada. Si un framework de agente te permite elegir un modelo barato para pasos pequeños y uno más fuerte para planificación, aquí ambos roles usarán el mismo modelo.
El resumen honesto es que la infraestructura está completa y la pregunta restante es la calidad del modelo en tus tareas. Esa es una pregunta empírica, y el crédito de prueba existe para responderla.
Un bucle de agente funcional
Este ejemplo da al modelo dos herramientas, una para leer un archivo y otra para ejecutar un comando en un directorio sandbox, y hace un bucle hasta que el modelo deja de pedir herramientas. Ejecútalo en una carpeta desechable, ya que la herramienta de comando ejecuta lo que el modelo proponga. El punto es la estructura: añade el mensaje del asistente, ejecuta cada llamada, añade un mensaje tool por llamada, repite.
import json, os, subprocess
from openai import OpenAI
client = OpenAI(base_url="https://api.qwenapis.com/v1", api_key=os.environ["QWENAPIS_KEY"])
TOOLS = [
{"type": "function", "function": {
"name": "read_file", "description": "Read a text file from the working directory",
"parameters": {"type": "object", "properties": {"path": {"type": "string"}}, "required": ["path"]}}},
{"type": "function", "function": {
"name": "run", "description": "Run a shell command and return its output",
"parameters": {"type": "object", "properties": {"cmd": {"type": "string"}}, "required": ["cmd"]}}},
]
def call_tool(name, args):
if name == "read_file":
return open(args["path"], encoding="utf-8").read()[:20000]
if name == "run":
p = subprocess.run(args["cmd"], shell=True, capture_output=True, text=True, timeout=60)
return (p.stdout + p.stderr)[-8000:]
return "unknown tool"
messages = [
{"role": "system", "content": "You fix failing tests. Use the tools, then reply with a short summary."},
{"role": "user", "content": "Run pytest, find why it fails, and tell me the fix."},
]
for step in range(12):
r = client.chat.completions.create(model="uncensored", messages=messages, tools=TOOLS, temperature=0.2)
msg = r.choices[0].message
messages.append(msg)
if not msg.tool_calls:
print(msg.content)
break
for tc in msg.tool_calls:
try:
out = call_tool(tc.function.name, json.loads(tc.function.arguments))
except Exception as e:
out = f"tool error: {e}"
messages.append({"role": "tool", "tool_call_id": tc.id, "content": out})
Tres detalles mantienen un bucle como este saludable. Limita el número de pasos, como lo hace range(12). Recorta la salida de las herramientas, ya que cada carácter devuelto se convierte en entrada para la siguiente llamada. Usa una temperatura baja para tareas de edición; 0.2 es un punto de partida razonable y puedes subirla para pasos de generación de ideas.
Ejecutar varios agentes sin llegar a 429
Un único agente es secuencial y rara vez supera un límite. Una flota de ellos, sí. Con más de 8 peticiones simultáneas, la API responde con 429 y el código concurrency, y con más de 300 en un minuto responde con 429 y rate_limited. Una sobrecarga temporal también devuelve 429, con el encabezado Retry-After: 5. Las peticiones en streaming mantienen su espacio hasta que termina la transmisión, por lo que una respuesta larga transmitida cuenta durante toda su duración.
import asyncio, os
from openai import AsyncOpenAI, RateLimitError
client = AsyncOpenAI(base_url="https://api.qwenapis.com/v1", api_key=os.environ["QWENAPIS_KEY"])
gate = asyncio.Semaphore(8)
async def ask(prompt, tries=4):
async with gate:
for attempt in range(tries):
try:
r = await client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": prompt}],
)
return r.choices[0].message.content
except RateLimitError:
await asyncio.sleep(5 * (attempt + 1))
return None
async def main():
jobs = [ask(f"Write a docstring for function number {i}.") for i in range(40)]
print(len(await asyncio.gather(*jobs)))
asyncio.run(main())
El semáforo te mantiene en 8 en vuelo, y la espera vuelve a intentarlo cuando un 429 se cuela de todos modos. Como las peticiones fallidas no se cobran, los reintentos no cuestan nada extra. Si te acercas más al límite, establece el semáforo en 6 para dejar espacio a una sesión interactiva con la misma clave.
Cuánto cuesta una ejecución de agente
Los agentes se cobran por cuánto contexto reenvían, no por cuánto código escriben. Toma una ejecución de corrección de errores de 12 pasos. El contexto crece a medida que se acumula la salida de las herramientas, así que asume un promedio de 20.000 tokens de entrada y 600 tokens de salida por paso.
- Entrada: 12 x 20.000 = 240.000 tokens x $0,15 / 1M = $0,036
- Salida: 12 x 600 = 7.200 tokens x $0,50 / 1M = $0,0036
- Por ejecución: $0.0396
- 50 ejecuciones al día: 50 x $0,0396 = $1,98
Las tarifas son $0.15 por 1M de tokens de entrada y $0.50 por 1M de tokens de salida, facturadas desde el crédito prepago que nunca caduca. Una recarga de $20 cubre aproximadamente 505 ejecuciones de este tipo ($20 / $0.0396). La página de precios lista los niveles de bonificación, y un hábito ahorra más que cualquier nivel: mantén la salida de las herramientas corta. Reducir a la mitad lo que retroalimentas reduce a la mitad la línea dominante.
Prompting de un modelo general para trabajo de código
Un modelo que no se vende como modelo de código aún puede funcionar bien en código si el prompt le da un trabajo claro. Pon el lenguaje, la versión del framework y las restricciones en el mensaje del sistema, por ejemplo la versión de Python y la regla de que no se permiten nuevas dependencias. Pide un cambio a la vez. Dale la salida de la prueba fallida tal cual en lugar de describirla, porque el texto exacto del error lleva más información que un parafraseo.
Para ediciones, pide un diff unificado o el reemplazo completo de una función, y rechaza cualquier otra cosa. El texto libre alrededor del código es difícil de aplicar automáticamente. El modo JSON ayuda cuando quieres un plan como datos, como una lista de archivos con una razón para cada cambio. Después de que el modelo proponga un parche, ejecuta las pruebas tú mismo y retroalimenta el resultado; no aceptes la afirmación del modelo de que las pruebas pasan.
Mantén la temperatura baja para las ediciones y súbela solo para la lluvia de ideas. Usa un seed fijo cuando compares dos versiones de prompt, para que las diferencias vengan del prompt y no del ruido de muestreo. La misma disciplina se aplica a cualquier modelo, y es lo que convierte una ejecución de prueba en una comparación justa con lo que uses hoy.
Elegir entre esto y un modelo de código con nombre
Usa un modelo de código dedicado de su propio proveedor cuando tu trabajo necesite ese modelo específico, por ejemplo porque lo has medido en tu código, porque un estándar de equipo lo requiere, o porque dependes de una función que solo ese proveedor ofrece. Revisa sus precios y límites actuales antes de comprometerte.
Usa esta API cuando los rechazos sean lo que te frena, cuando quieras un único endpoint compatible con OpenAI que funcione con los frameworks que ya ejecutas, o cuando el pago por uso desde un saldo pequeño te convenga más que un plan. También tiene sentido como segundo endpoint: envía ediciones rutinarias a tu modelo habitual y enruta las peticiones que un filtro de política rechaza a esta. Cambiar es una base URL y un nombre de modelo, así que el costo de probar es bajo.
Para probarlo, lee la guía de primera petición, crea una clave con los pasos de clave, y reclama el crédito de prueba de $0,50: un clic, sin tarjeta, uno por persona, válido por 7 días. Una clave de prueba permite 2 peticiones simultáneas y 60 por minuto, lo cual es suficiente para ejecutar el bucle anterior una docena de veces. Los prompts no se usan para entrenamiento, así que tu repositorio de prueba queda fuera de cualquier conjunto de entrenamiento.
Más guías
Preguntas y respuestas
¿Es esta la API oficial de Qwen3-Coder-Next?
No. Es un proveedor independiente con un único modelo de pesos abiertos, con ID uncensored. No es una API de un proveedor oficial y no ofrece un modelo listado con ese nombre.
¿Admite llamadas a funciones para agentes de código?
Sí. Pasas las herramientas y tool_choice, recibes tool_calls (también en streaming) y devuelves los resultados como mensajes con role: tool.
¿Qué tamaño de base de código cabe en una petición?
La ventana es de 100,000 tokens para prompt más completación en conjunto. Envía solo los archivos relevantes para la tarea y recorta la salida de las herramientas para dejar espacio para la respuesta.
¿Puedo ejecutar varios agentes a la vez?
Hasta 8 solicitudes concurrentes y 300 por minuto con una clave completa. Una clave de prueba permite 2 y 60. Por encima de eso obtienes HTTP 429, así que usa un semáforo.
¿Admite embeddings para búsqueda de código?
No. La API cubre respuestas de chat y una lista de modelos únicamente, así que usa una fuente de embeddings separada para la búsqueda vectorial.
Tu clave está a un formulario de distancia
Crea una cuenta, copia la clave, cambia la URL base. Esa es toda la configuración.