Quickstart

Inizia a usare l’API Venice in pochi minuti. Genera una API key, esegui la tua prima richiesta e comincia a sviluppare.

Ottieni la tua API key

Vai nelle tue impostazioni API di Venice e genera una nuova API key.Per una guida dettagliata, consulta la guida alle API key.

Configura la tua API key

Aggiungi la tua API key all’ambiente. Puoi esportarla nella shell:

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

Oppure aggiungerla a un file .env nel tuo progetto:

VENICE_API_KEY=your-api-key-here

Installa l'SDK

Venice è compatibile con OpenAI, quindi puoi usare l’SDK OpenAI. Se preferisci usare cURL o richieste HTTP raw, puoi saltare questo passaggio.

pip install openai

Invia la tua prima richiesta

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)

Ruoli dei messaggi:

system - Istruzioni su come il modello deve comportarsi
user - I tuoi prompt o domande
assistant - Risposte precedenti del modello (per conversazioni multi-turno)
tool - Risultati delle chiamate a funzione (quando usi i tool)

Cambia modello modificando l'ID

Ogni richiesta include un model ID. Per usare un modello diverso, cambia il valore di model nella richiesta. Scelte comuni:

zai-org-glm-5 - Modello predefinito per la maggior parte dei casi d’uso
kimi-k2-6 - Reasoning solido per attività più complesse
claude-opus-4-8 - Modello ad alta intelligenza per task complessi
venice-uncensored-1-2 - Modello uncensored di Venice

Visualizza tutti i modelli

Sfoglia l’elenco completo dei modelli con prezzi, capacità e limiti di contesto

Usa i Venice Parameters

Puoi scegliere di abilitare funzionalità specifiche di Venice come la web search tramite 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)

Consulta tutti i parametri disponibili.

Abilita lo streaming (opzionale)

Trasmetti le risposte in tempo reale 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="")

Personalizza il comportamento della risposta (opzionale)

Controlla come il modello risponde con parametri come temperature, max tokens e altri:

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)

Consulta la documentazione di Chat Completions per maggiori informazioni su tutti i parametri supportati.

Altre capacità

Generazione di immagini

Crea immagini da prompt testuali usando modelli di diffusione:

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: la risposta restituisce immagini codificate in base64 nell’array images. Decodifica la stringa base64 per salvare o visualizzare l’immagine. Modelli di immagini popolari:

qwen-image - Generazione di immagini di altissima qualità
venice-sd35 - Scelta predefinita, funziona con tutte le funzionalità
hidream - Generazione veloce per uso in produzione

Visualizza tutti i modelli di immagini

Vedi tutti i modelli di immagini disponibili con prezzi e capacità

Per opzioni di parametri più avanzate come cfg_scale, negative_prompt, style_preset, seed, variants e altre, consulta la Images API Reference.

Editing di immagini

Modifica immagini esistenti con inpainting basato su AI tramite il modello 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: l’editor di immagini usa il modello Qwen-Image ed è un endpoint sperimentale. Invia l’immagine di input come stringa codificata in base64; l’API restituisce l’immagine modificata come dati binari. Consulta la Image Edit API per tutti i parametri.

Upscaling di immagini

Migliora le immagini portandole a risoluzioni più alte:

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: invia l’immagine di input come stringa codificata in base64; l’API restituisce l’immagine con upscaling come dati binari. Consulta la Image Upscale API per tutti i parametri.

Text-to-Speech

Converti testo in audio con oltre 50 voci multilingue:

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)

Il modello tts-kokoro supporta oltre 50 voci multilingue, tra cui af_sky, af_nova, am_liam, bf_emma, zf_xiaobei e jm_kumo. Consulta la TTS API per tutte le opzioni di voce.

Speech-to-Text

Trascrivi file audio in testo:

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

Formati supportati: WAV, FLAC, MP3, M4A, AAC, MP4. Abilita timestamps=true per ottenere dati di timing a livello di parola. Consulta la Transcriptions API per tutte le opzioni.

Embeddings

Genera vector embedding per ricerca semantica, RAG e raccomandazioni:

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

Consulta la Embeddings API per l’elaborazione batch e le opzioni avanzate.

Vision (multimodale)

Analizza immagini insieme al testo usando modelli vision-capable come 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

Definisci funzioni che i modelli possono chiamare per interagire con tool e API esterni:

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)

Prossimi passi

Ora che hai eseguito le prime richieste, esplora tutto ciò che l’API Venice ha da offrire:

Sfoglia i modelli

Confronta tutti i modelli disponibili con capacità, prezzi e limiti di contesto

API Reference

Esplora la documentazione dettagliata dell’API con tutti gli endpoint e i parametri

Risposte strutturate

Scopri come ottenere risposte JSON con schemi garantiti

Guida agli AI agent

Sviluppa con app per agent, coding agent, tool MCP, skill e workflow crypto

Risorse aggiuntive

Rate limiting

Comprendi i rate limit e le best practice per l’uso in produzione

Codici di errore

Riferimento per gestire gli errori dell’API e risolvere i problemi

Postman Collection

Importa la nostra collection Postman completa per testare facilmente

Privacy e sicurezza

Scopri l’architettura privacy-first di Venice e la gestione dei dati

Hai bisogno di aiuto?

Community Discord: unisciti al nostro server Discord per supporto e discussioni
Documentazione: sfoglia la nostra API reference completa
Status page: controlla lo stato del servizio su veniceai-status.com
Twitter: segui @AskVenice per gli aggiornamenti

​Quickstart

Visualizza tutti i modelli

​Altre capacità

​Generazione di immagini

Visualizza tutti i modelli di immagini

​Editing di immagini

​Upscaling di immagini

​Text-to-Speech

​Speech-to-Text

​Embeddings

​Vision (multimodale)

​Function calling

​Prossimi passi