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 con screenshot, 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