Quickstart | Venice API Docs

Empieza a usar la API de Venice en minutos. Genera una API key, haz tu primera solicitud y empieza a construir.

Inicio rápido

Obtén tu API key

Ve a tu configuración de la API de Venice y genera una nueva API key.Para un recorrido detallado, consulta la guía de API Key.

Configura tu API key

Añade tu API key a tu entorno. Puedes exportarla en tu shell:

export VENICE_API_KEY='your-api-key-here'

O añadirla a un archivo .env en tu proyecto:

VENICE_API_KEY=your-api-key-here

Instala el SDK

Venice es compatible con OpenAI, por lo que puedes usar el SDK de OpenAI. Si prefieres usar cURL o solicitudes HTTP en bruto, puedes saltarte este paso.

pip install openai

npm install openai

Envía tu primera solicitud

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("VENICE_API_KEY"),
    base_url="https://api.venice.ai/api/v1"
)

completion = client.chat.completions.create(
    model="zai-org-glm-5",
    messages=[
        {"role": "system", "content": "You are a helpful AI assistant"},
        {"role": "user", "content": "Why is privacy important?"}
    ]
)

print(completion.choices[0].message.content)

import OpenAI from 'openai';

const client = new OpenAI({
    apiKey: process.env.VENICE_API_KEY,
    baseURL: 'https://api.venice.ai/api/v1'
});

const completion = await client.chat.completions.create({
    model: 'zai-org-glm-5',
    messages: [
        { role: 'system', content: 'You are a helpful AI assistant' },
        { role: 'user', content: 'Why is privacy important?' }
    ]
});

console.log(completion.choices[0].message.content);

curl https://api.venice.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $VENICE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "zai-org-glm-5",
    "messages": [
      {"role": "system", "content": "You are a helpful AI assistant"},
      {"role": "user", "content": "Why is privacy important?"}
    ]
  }'

Roles de mensaje:

system - Instrucciones para el comportamiento del modelo
user - Tus prompts o preguntas
assistant - Respuestas previas del modelo (para conversaciones multi-turno)
tool - Resultados de llamadas a funciones (al usar tools)

Cambia de modelo cambiando el ID del modelo

Cada solicitud incluye un ID de model. Para usar un modelo diferente, cambia el valor de model en tu solicitud. Opciones populares:

zai-org-glm-5 - Modelo predeterminado para la mayoría de casos de uso
kimi-k2-6 - Razonamiento sólido para tareas más complejas
claude-opus-4-8 - Modelo de alta inteligencia para tareas complejas
venice-uncensored-1-2 - Modelo sin censura de Venice

Ver todos los modelos

Explora la lista completa de modelos con precios, capacidades y límites de contexto

Usa Venice Parameters

Puedes optar por activar funciones específicas de Venice como la búsqueda web mediante venice_parameters:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("VENICE_API_KEY"),
    base_url="https://api.venice.ai/api/v1"
)

completion = client.chat.completions.create(
    model="zai-org-glm-5",
    messages=[
        {"role": "user", "content": "What are the latest developments in AI?"}
    ],
    extra_body={
        "venice_parameters": {
            "enable_web_search": "auto",
            "include_venice_system_prompt": True
        }
    }
)

print(completion.choices[0].message.content)

import OpenAI from 'openai';

const client = new OpenAI({
    apiKey: process.env.VENICE_API_KEY,
    baseURL: 'https://api.venice.ai/api/v1'
});

const completion = await client.chat.completions.create({
    model: 'zai-org-glm-5',
    messages: [
        { role: 'user', content: 'What are the latest developments in AI?' }
    ],
    venice_parameters: {
        enable_web_search: 'auto',
        include_venice_system_prompt: true
    }
});

console.log(completion.choices[0].message.content);

curl https://api.venice.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $VENICE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "zai-org-glm-5",
    "messages": [
      {"role": "user", "content": "What are the latest developments in AI?"}
    ],
    "venice_parameters": {
      "enable_web_search": "auto",
      "include_venice_system_prompt": true
    }
  }'

Consulta todos los parámetros disponibles.

Activa el streaming (opcional)

Transmite respuestas en tiempo real usando stream=True:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("VENICE_API_KEY"),
    base_url="https://api.venice.ai/api/v1"
)

stream = client.chat.completions.create(
    model="zai-org-glm-5",
    messages=[{"role": "user", "content": "Write a short story about AI"}],
    stream=True
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="")

import OpenAI from 'openai';

const client = new OpenAI({
    apiKey: process.env.VENICE_API_KEY,
    baseURL: 'https://api.venice.ai/api/v1'
});

const stream = await client.chat.completions.create({
    model: 'zai-org-glm-5',
    messages: [{ role: 'user', content: 'Write a short story about AI' }],
    stream: true
});

for await (const chunk of stream) {
    if (chunk.choices && chunk.choices[0]?.delta?.content) {
        process.stdout.write(chunk.choices[0].delta.content);
    }
}

curl https://api.venice.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $VENICE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "zai-org-glm-5",
    "messages": [
      {"role": "user", "content": "Write a short story about AI"}
    ],
    "stream": true
  }'

Personaliza el comportamiento de respuesta (opcional)

Controla cómo responde el modelo con parámetros como temperature, max tokens y más:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("VENICE_API_KEY"),
    base_url="https://api.venice.ai/api/v1"
)

completion = client.chat.completions.create(
    model="zai-org-glm-5",
    messages=[
        {"role": "system", "content": "You are a creative storyteller"},
        {"role": "user", "content": "Tell me a creative story"}
    ],
    temperature=0.8,
    max_tokens=500,
    top_p=0.9,
    frequency_penalty=0.5,
    presence_penalty=0.5,
    extra_body={
        "venice_parameters": {
            "include_venice_system_prompt": False
        }
    }
)

print(completion.choices[0].message.content)

import OpenAI from 'openai';

const client = new OpenAI({
    apiKey: process.env.VENICE_API_KEY,
    baseURL: 'https://api.venice.ai/api/v1'
});

const completion = await client.chat.completions.create({
    model: 'zai-org-glm-5',
    messages: [
        { role: 'system', content: 'You are a creative storyteller' },
        { role: 'user', content: 'Tell me a creative story' }
    ],
    temperature: 0.8,
    max_tokens: 500,
    top_p: 0.9,
    frequency_penalty: 0.5,
    presence_penalty: 0.5,
    venice_parameters: {
        include_venice_system_prompt: false
    }
});

console.log(completion.choices[0].message.content);

curl https://api.venice.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $VENICE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "zai-org-glm-5",
    "messages": [
      {"role": "system", "content": "You are a creative storyteller"},
      {"role": "user", "content": "Tell me a creative story"}
    ],
    "temperature": 0.8,
    "max_tokens": 500,
    "top_p": 0.9,
    "frequency_penalty": 0.5,
    "presence_penalty": 0.5,
    "stream": false,
    "venice_parameters": {
      "include_venice_system_prompt": false
    }
  }'

Consulta la documentación de Chat Completions para más información sobre todos los parámetros admitidos.

Más capacidades

Generación de imágenes

Crea imágenes a partir de prompts de texto usando modelos de difusión:

import os
import requests

url = "https://api.venice.ai/api/v1/image/generate"

payload = {
    "model": "venice-sd35",
    "prompt": "A cyberpunk city with neon lights and rain",
    "width": 1024,
    "height": 1024,
    "format": "webp"
}

headers = {
    "Authorization": f"Bearer {os.getenv('VENICE_API_KEY')}",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

const url = 'https://api.venice.ai/api/v1/image/generate';

const options = {
    method: 'POST',
    headers: {
        'Authorization': `Bearer ${process.env.VENICE_API_KEY}`,
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        model: 'venice-sd35',
        prompt: 'A cyberpunk city with neon lights and rain',
        width: 1024,
        height: 1024,
        format: 'webp'
    })
};

try {
    const response = await fetch(url, options);
    const data = await response.json();
    console.log(data);
} catch (error) {
    console.error(error);
}

curl https://api.venice.ai/api/v1/image/generate \
  -H "Authorization: Bearer $VENICE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "venice-sd35",
    "prompt": "A cyberpunk city with neon lights and rain",
    "width": 1024,
    "height": 1024
  }'

Nota: la respuesta devuelve imágenes codificadas en base64 en el array images. Decodifica la cadena base64 para guardar o mostrar la imagen. Modelos de imagen populares:

qwen-image - Generación de imágenes de la máxima calidad
venice-sd35 - Opción por defecto, funciona con todas las funciones
hidream - Generación rápida para uso en producción

Ver todos los modelos de imagen

Mira todos los modelos de imagen disponibles con precios y capacidades

Para opciones de parámetros más avanzadas como cfg_scale, negative_prompt, style_preset, seed, variants y más, consulta la referencia de la API de imágenes.

Edición de imágenes

Modifica imágenes existentes con inpainting impulsado por IA usando el modelo Qwen-Image:

import os
import requests
import base64

url = "https://api.venice.ai/api/v1/image/edit"

with open("image.jpg", "rb") as f:
    image_base64 = base64.b64encode(f.read()).decode('utf-8')

payload = {
    "prompt": "Colorize",
    "image": image_base64
}

headers = {
    "Authorization": f"Bearer {os.getenv('VENICE_API_KEY')}",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

with open("edited_image.png", "wb") as f:
    f.write(response.content)

import fs from 'fs';

const imageBuffer = fs.readFileSync('image.jpg');
const imageBase64 = imageBuffer.toString('base64');

const options = {
    method: 'POST',
    headers: {
        'Authorization': `Bearer ${process.env.VENICE_API_KEY}`,
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        prompt: 'Colorize',
        image: imageBase64
    })
};

const response = await fetch('https://api.venice.ai/api/v1/image/edit', options);
const imageData = await response.arrayBuffer();
fs.writeFileSync('edited_image.png', Buffer.from(imageData));

curl --request POST \
  --url https://api.venice.ai/api/v1/image/edit \
  --header "Authorization: Bearer $VENICE_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "prompt": "Colorize",
    "image": "iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAIAAAB7GkOtAAAAIGNIUk0A..."
  }'

Nota: el editor de imágenes utiliza el modelo Qwen-Image y es un endpoint experimental. Envía la imagen de entrada como cadena codificada en base64 y la API devuelve la imagen editada como datos binarios. Consulta la API de edición de imágenes para todos los parámetros.

Escalado de imágenes

Mejora y escala imágenes a resoluciones más altas:

import os
import requests
import base64

url = "https://api.venice.ai/api/v1/image/upscale"

with open("image.jpg", "rb") as f:
    image_base64 = base64.b64encode(f.read()).decode('utf-8')

payload = {
    "image": image_base64,
    "scale": 2
}

headers = {
    "Authorization": f"Bearer {os.getenv('VENICE_API_KEY')}",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

with open("upscaled_image.png", "wb") as f:
    f.write(response.content)

import fs from 'fs';

const imageBuffer = fs.readFileSync('image.jpg');
const imageBase64 = imageBuffer.toString('base64');

const options = {
    method: 'POST',
    headers: {
        'Authorization': `Bearer ${process.env.VENICE_API_KEY}`,
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        image: imageBase64,
        scale: 2
    })
};

const response = await fetch('https://api.venice.ai/api/v1/image/upscale', options);
const imageData = await response.arrayBuffer();
fs.writeFileSync('upscaled_image.png', Buffer.from(imageData));

curl --request POST \
  --url https://api.venice.ai/api/v1/image/upscale \
  --header "Authorization: Bearer $VENICE_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "image": "iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAIAAAB7GkOtAAAAIGNIUk0A...",
    "scale": 2
  }'

Nota: envía la imagen de entrada como cadena codificada en base64 y la API devuelve la imagen escalada como datos binarios. Consulta la API de escalado de imágenes para todos los parámetros.

Texto a voz

Convierte texto en audio con más de 50 voces multilingües:

import os
import requests

response = requests.post(
    "https://api.venice.ai/api/v1/audio/speech",
    headers={
        "Authorization": f"Bearer {os.getenv('VENICE_API_KEY')}",
        "Content-Type": "application/json"
    },
    json={
        "input": "Hello, welcome to Venice Voice.",
        "model": "tts-kokoro",
        "voice": "af_sky"
    }
)

with open("speech.mp3", "wb") as f:
    f.write(response.content)

import fs from 'fs';

const response = await fetch('https://api.venice.ai/api/v1/audio/speech', {
    method: 'POST',
    headers: {
        'Authorization': `Bearer ${process.env.VENICE_API_KEY}`,
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        input: 'Hello, welcome to Venice Voice.',
        model: 'tts-kokoro',
        voice: 'af_sky'
    })
});

const audioBuffer = await response.arrayBuffer();
fs.writeFileSync('speech.mp3', Buffer.from(audioBuffer));

curl --request POST \
  --url https://api.venice.ai/api/v1/audio/speech \
  --header "Authorization: Bearer $VENICE_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "input": "Hello, welcome to Venice Voice.",
    "model": "tts-kokoro",
    "voice": "af_sky"
  }' \
  --output speech.mp3

El modelo tts-kokoro admite más de 50 voces multilingües, incluyendo af_sky, af_nova, am_liam, bf_emma, zf_xiaobei y jm_kumo. Consulta la API de TTS para todas las opciones de voz.

Voz a texto

Transcribe archivos de audio a texto:

import os
import requests

url = "https://api.venice.ai/api/v1/audio/transcriptions"

with open("audio.mp3", "rb") as f:
    response = requests.post(
        url,
        headers={"Authorization": f"Bearer {os.getenv('VENICE_API_KEY')}"},
        files={"file": f},
        data={
            "model": "nvidia/parakeet-tdt-0.6b-v3",
            "response_format": "json"
        }
    )

print(response.json())

import fs from 'fs';
import FormData from 'form-data';

const form = new FormData();
form.append('file', fs.createReadStream('audio.mp3'));
form.append('model', 'nvidia/parakeet-tdt-0.6b-v3');
form.append('response_format', 'json');

const response = await fetch('https://api.venice.ai/api/v1/audio/transcriptions', {
    method: 'POST',
    headers: {
        'Authorization': `Bearer ${process.env.VENICE_API_KEY}`,
        ...form.getHeaders()
    },
    body: form
});

const data = await response.json();
console.log(data);

curl --request POST \
  --url https://api.venice.ai/api/v1/audio/transcriptions \
  --header "Authorization: Bearer $VENICE_API_KEY" \
  --form file=@audio.mp3 \
  --form model=nvidia/parakeet-tdt-0.6b-v3 \
  --form response_format=json

Formatos admitidos: WAV, FLAC, MP3, M4A, AAC, MP4. Activa timestamps=true para obtener datos de tiempo a nivel de palabra. Consulta la API de transcripciones para todas las opciones.

Embeddings

Genera vectores de embeddings para búsqueda semántica, RAG y recomendaciones:

import os
import requests

url = "https://api.venice.ai/api/v1/embeddings"

payload = {
    "model": "text-embedding-bge-m3",
    "input": "Privacy-first AI infrastructure for semantic search",
    "encoding_format": "float"
}

headers = {
    "Authorization": f"Bearer {os.getenv('VENICE_API_KEY')}",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

const url = 'https://api.venice.ai/api/v1/embeddings';

const options = {
    method: 'POST',
    headers: {
        'Authorization': `Bearer ${process.env.VENICE_API_KEY}`,
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        model: 'text-embedding-bge-m3',
        input: 'Privacy-first AI infrastructure for semantic search',
        encoding_format: 'float'
    })
};

try {
    const response = await fetch(url, options);
    const data = await response.json();
    console.log(data);
} catch (error) {
    console.error(error);
}

curl --request POST \
  --url https://api.venice.ai/api/v1/embeddings \
  --header "Authorization: Bearer $VENICE_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "model": "text-embedding-bge-m3",
    "input": "Privacy-first AI infrastructure for semantic search",
    "encoding_format": "float"
  }'

Consulta la API de embeddings para procesamiento por lotes y opciones avanzadas.

Vision (multimodal)

Analiza imágenes junto con texto usando modelos con capacidad de visión como qwen3-vl-235b-a22b:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("VENICE_API_KEY"),
    base_url="https://api.venice.ai/api/v1"
)

response = client.chat.completions.create(
    model="qwen3-vl-235b-a22b",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What is in this image?"},
                {
                    "type": "image_url",
                    "image_url": {"url": "https://www.gstatic.com/webp/gallery/1.jpg"}
                }
            ]
        }
    ]
)

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

import OpenAI from 'openai';

const client = new OpenAI({
    apiKey: process.env.VENICE_API_KEY,
    baseURL: 'https://api.venice.ai/api/v1'
});

const response = await client.chat.completions.create({
    model: 'qwen3-vl-235b-a22b',
    messages: [
        {
            role: 'user',
            content: [
                { type: 'text', text: 'What is in this image?' },
                {
                    type: 'image_url',
                    image_url: { url: 'https://www.gstatic.com/webp/gallery/1.jpg' }
                }
            ]
        }
    ]
});

console.log(response.choices[0].message.content);

curl https://api.venice.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $VENICE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3-vl-235b-a22b",
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": "What is in this image?"
          },
          {
            "type": "image_url",
            "image_url": {
              "url": "https://www.gstatic.com/webp/gallery/1.jpg"
            }
          }
        ]
      }
    ]
  }'

Function calling

Define funciones que los modelos pueden invocar para interactuar con herramientas y APIs externas:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("VENICE_API_KEY"),
    base_url="https://api.venice.ai/api/v1"
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather in a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city and state"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="zai-org-glm-5",
    messages=[{"role": "user", "content": "What's the weather in San Francisco?"}],
    tools=tools
)

print(response.choices[0].message)

import OpenAI from 'openai';

const client = new OpenAI({
    apiKey: process.env.VENICE_API_KEY,
    baseURL: 'https://api.venice.ai/api/v1'
});

const tools = [
    {
        type: 'function',
        function: {
            name: 'get_weather',
            description: 'Get the current weather in a location',
            parameters: {
                type: 'object',
                properties: {
                    location: {
                        type: 'string',
                        description: 'The city and state'
                    }
                },
                required: ['location']
            }
        }
    }
];

const response = await client.chat.completions.create({
    model: 'zai-org-glm-5',
    messages: [{ role: 'user', content: "What's the weather in San Francisco?" }],
    tools: tools
});

console.log(response.choices[0].message);

curl https://api.venice.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $VENICE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "zai-org-glm-5",
    "messages": [
      {
        "role": "user",
        "content": "What'\''s the weather in San Francisco?"
      }
    ],
    "tools": [
      {
        "type": "function",
        "function": {
          "name": "get_weather",
          "description": "Get the current weather in a location",
          "parameters": {
            "type": "object",
            "properties": {
              "location": {
                "type": "string",
                "description": "The city and state"
              }
            },
            "required": ["location"]
          }
        }
      }
    ]
  }'

Próximos pasos

Ahora que ya has hecho tus primeras solicitudes, explora más de lo que ofrece la API de Venice:

Explorar modelos

Compara todos los modelos disponibles con sus capacidades, precios y límites de contexto

Referencia de la API

Explora la documentación detallada de la API con todos los endpoints y parámetros

Respuestas estructuradas

Aprende a obtener respuestas JSON con esquemas garantizados

Guía de agentes de IA

Construye con apps de agentes, agentes de programación, herramientas MCP, skills y flujos de trabajo cripto

Recursos adicionales

Límites de velocidad

Comprende los límites de velocidad y las mejores prácticas para uso en producción

Códigos de error

Referencia para gestionar errores de la API y resolver problemas

Colección de Postman

Importa nuestra colección completa de Postman para pruebas fáciles

Privacidad y seguridad

Aprende sobre la arquitectura privacy-first de Venice y el tratamiento de datos

¿Necesitas ayuda?

Comunidad de Discord: únete a nuestro servidor de Discord para soporte y debates
Documentación: explora nuestra referencia completa de la API
Página de estado: comprueba el estado del servicio en veniceai-status.com
Twitter: sigue a @AskVenice para actualizaciones

​Inicio rápido

Ver todos los modelos

​Más capacidades

​Generación de imágenes

Ver todos los modelos de imagen

​Edición de imágenes

​Escalado de imágenes

​Texto a voz

​Voz a texto

​Embeddings

​Vision (multimodal)

​Function calling

​Próximos pasos