Início rápido

Comece a usar a API Venice em minutos. Gere uma chave de API, faça sua primeira requisição e comece a construir.

Obtenha sua chave de API

Vá até suas Configurações da API Venice e gere uma nova chave de API.Para um passo a passo detalhado com screenshots, confira o guia de chave de API.

Configure sua chave de API

Adicione sua chave de API ao seu ambiente. Você pode exportá-la no seu shell:

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

Ou adicione-a a um arquivo .env no seu projeto:

VENICE_API_KEY=your-api-key-here

Instale o SDK

A Venice é compatível com a OpenAI, então você pode usar o SDK da OpenAI. Se preferir usar cURL ou requisições HTTP brutas, pode pular este passo.

pip install openai

Envie sua primeira requisição

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)

Papéis de mensagem:

system - Instruções de como o modelo deve se comportar
user - Seus prompts ou perguntas
assistant - Respostas anteriores do modelo (para conversas com múltiplos turnos)
tool - Resultados de chamadas de função (ao usar ferramentas)

Troque de modelo alterando o ID do modelo

Toda requisição inclui um model ID. Para usar um modelo diferente, altere o valor de model na sua requisição. Escolhas populares:

zai-org-glm-5 - Modelo padrão para a maioria dos casos de uso
kimi-k2-6 - Raciocínio forte para tarefas mais complexas
claude-opus-4-8 - Modelo de alta inteligência para tarefas complexas
venice-uncensored-1-2 - Modelo sem censura da Venice

Ver todos os modelos

Navegue pela lista completa de modelos com preços, capacidades e limites de contexto

Use os parâmetros da Venice

Você pode optar por habilitar recursos específicos da Venice como busca na web usando 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)

Veja todos os parâmetros disponíveis.

Habilite o streaming (opcional)

Faça streaming das respostas em tempo 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="")

Personalize o comportamento da resposta (opcional)

Controle como o modelo responde com parâmetros como temperature, max tokens e mais:

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)

Confira a documentação de Chat Completions para mais informações sobre todos os parâmetros suportados.

Mais capacidades

Geração de imagens

Crie imagens a partir de prompts de texto usando modelos de difusão:

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())

Nota: A resposta retorna imagens codificadas em base64 no array images. Decodifique a string base64 para salvar ou exibir a imagem. Modelos de imagem populares:

qwen-image - Geração de imagem da mais alta qualidade
venice-sd35 - Escolha padrão, funciona com todos os recursos
hidream - Geração rápida para uso em produção

Ver todos os modelos de imagem

Veja todos os modelos de imagem disponíveis com preços e capacidades

Para opções de parâmetros mais avançadas como cfg_scale, negative_prompt, style_preset, seed, variants e mais, confira a referência da API de imagens.

Edição de imagem

Modifique imagens existentes com inpainting com IA usando o 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)

Nota: O editor de imagens usa o modelo Qwen-Image e é um endpoint experimental. Envie a imagem de entrada como uma string codificada em base64, e a API retornará a imagem editada como dados binários. Veja a API de edição de imagens para todos os parâmetros.

Upscaling de imagem

Aprimore e faça upscale de imagens para resoluções mais 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)

Nota: Envie a imagem de entrada como uma string codificada em base64, e a API retornará a imagem com upscale como dados binários. Veja a API de upscale de imagem para todos os parâmetros.

Texto para fala

Converta texto em áudio com mais de 50 vozes multilíngues:

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)

O modelo tts-kokoro suporta mais de 50 vozes multilíngues, incluindo af_sky, af_nova, am_liam, bf_emma, zf_xiaobei e jm_kumo. Veja a API de TTS para todas as opções de voz.

Fala para texto

Transcreva arquivos de áudio em 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())

Formatos suportados: WAV, FLAC, MP3, M4A, AAC, MP4. Habilite timestamps=true para obter dados de tempo no nível de palavra. Veja a API de transcrições para todas as opções.

Embeddings

Gere embeddings vetoriais para busca semântica, RAG e recomendações:

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())

Veja a API de embeddings para processamento em lote e opções avançadas.

Visão (multimodal)

Analise imagens junto com texto usando modelos com capacidade de visão 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)

Function calling

Defina funções que os modelos podem chamar para interagir com ferramentas e 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)

Próximos passos

Agora que você fez suas primeiras requisições, explore mais do que a API Venice oferece:

Navegar pelos modelos

Compare todos os modelos disponíveis com suas capacidades, preços e limites de contexto

Referência da API

Explore a documentação detalhada da API com todos os endpoints e parâmetros

Respostas estruturadas

Aprenda a obter respostas em JSON com schemas garantidos

Guia de agentes de IA

Construa com apps de agente, agentes de programação, ferramentas MCP, skills e fluxos cripto

Recursos adicionais

Limites de taxa

Entenda os limites de taxa e as melhores práticas para uso em produção

Códigos de erro

Referência para tratar erros da API e solucionar problemas

Coleção do Postman

Importe nossa coleção completa do Postman para testes fáceis

Privacidade e segurança

Saiba mais sobre a arquitetura privacy-first da Venice e o tratamento de dados

Precisa de ajuda?

Comunidade no Discord: Entre no nosso servidor do Discord para suporte e discussões
Documentação: Navegue pela nossa referência completa da API
Página de status: Verifique o status do serviço em veniceai-status.com
Twitter: Siga @AskVenice para atualizações

​Início rápido

Ver todos os modelos

​Mais capacidades

​Geração de imagens

Ver todos os modelos de imagem

​Edição de imagem

​Upscaling de imagem

​Texto para fala

​Fala para texto

​Embeddings

​Visão (multimodal)

​Function calling

​Próximos passos