Venice API Docs

L’API pour un accès privé et sans restriction à l’intelligence.

Chat, image, audio et vidéo compatibles OpenAI derrière une seule clé API.

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-1",
    "messages": [{"role": "user", "content": "Build without permission."}]
  }'

import OpenAI from "openai";

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

const res = await client.chat.completions.create({
  model: "zai-org-glm-5-1",
  messages: [{ role: "user", content: "Build without permission." }],
});

import os
from openai import OpenAI

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

res = client.chat.completions.create(
    model="zai-org-glm-5-1",
    messages=[{"role": "user", "content": "Build without permission."}],
)

Endpoints

Une API pour toutes les modalités

Chat, image, audio, vidéo et embeddings derrière une seule clé API.

Chat Completions

Chat compatible OpenAI avec raisonnement, utilisation d’outils et streaming sur plus de 100 modèles de texte.

StreamingOutilsVision

Voir la référence →Génération d’image

Text-to-image, image-to-image, agrandissement et suppression d’arrière-plan sur des modèles photoréalistes, stylisés et non censurés.

Text-to-imageImage-to-imageUpscale

Voir la référence →Audio

Synthèse vocale avec plus de 50 voix multilingues, plus la transcription speech-to-text pour tout fichier audio.

TTSTranscription50+ voix

Voir la référence →Vidéo

Text-to-video, image-to-video et reference-to-video via une file d’attente de jobs synchrone ou asynchrone.

Text-to-videoImage-to-videoReference-to-video

Voir la référence →

Plus embeddings, entrées de fichiers, outils MCP et paiements par portefeuille. Voir tous les endpoints →

Agents

Conçu pour les agents IA

Inférence privée, outils MCP et workflows financés par portefeuille pour la messagerie, le codage et les agents onchain.

Applications d’agent

Connectez Venice à WhatsApp, Telegram, Discord et plus via OpenClaw, Hermes et NanoClaw.

Voir les intégrations →Agents de codage

Utilisez Claude Code, Cursor et Codex CLI avec les modèles Venice pour des workflows de codage privés.

Voir les intégrations →MCP + Skills

Exposez le chat, l’image, la vidéo, l’audio et les embeddings en tant qu’outils MCP ou skills runtime.

Voir les intégrations →

Explorez le hub Agents IA →

Modèles

Modèles populaires

Quelques-uns des modèles les plus utilisés sur Venice. Utilisez l’ID comme votre paramètre model.

Kimi K2.6Moonshot AI

Raisonnement frontière en open-weights. Solide en contexte long et utilisation d’outils, à une fraction des prix frontière.

256K contexte$0.85 / $4.66 par 1MPrivate

kimi-k2-6

Claude Opus 4.7Anthropic

Meilleur de sa catégorie pour le codage, la planification et les agents à long horizon qui doivent rester cohérents.

1M contexte$6.00 / $30.00 par 1MAnonymized

claude-opus-4-7

GPT-5.5OpenAI

Intelligence générale frontière avec 1M de contexte. Choix par défaut solide pour le chat, le RAG et le raisonnement multi-étapes.

1M contexte$6.25 / $37.50 par 1MAnonymized

openai-gpt-55

250+ modèlesTexte, image, audio et vidéoParcourir le catalogue →

Outils

Outils intégrés pour les modèles de chat

Activez la recherche web, attachez des fichiers ou interrogez une blockchain avec venice_parameters ou un endpoint natif Venice.

Recherche web

Web Scraping

Entrées de fichiers

Crypto RPC

Exemples de code de recherche web

Ajoutez une recherche web en temps réel avec citations à n’importe quel modèle de texte via enable_web_search.

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-1",
    "messages": [{"role": "user", "content": "What are the latest developments in AI?"}],
    "venice_parameters": {
      "enable_web_search": "auto"
    }
  }'

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-1",
  messages: [{ role: "user", content: "What are the latest developments in AI?" }],
  // @ts-expect-error - Venice-specific parameter
  venice_parameters: {
    enable_web_search: "auto",
  },
});

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

import os
from openai import OpenAI

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

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

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

# Alternative : ajoutez les paramètres directement à l'ID du modèle
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-1:enable_web_search=on&enable_web_citations=true",
    "messages": [{"role": "user", "content": "What are the latest developments in AI?"}]
  }'

Exemples de code de Web Scraping

Définissez enable_web_scraping: true et le modèle récupérera et lira toutes les URL du message utilisateur avant de répondre.

curl https://api.venice.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $VENICE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai-gpt-55",
    "messages": [
      {"role": "user", "content": "Summarize this post in five bullets: https://venice.ai/blog/how-to-use-venice-api"}
    ],
    "venice_parameters": {
      "enable_web_scraping": true
    }
  }'

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: "openai-gpt-55",
  messages: [
    {
      role: "user",
      content:
        "Summarize this post in five bullets: https://venice.ai/blog/how-to-use-venice-api",
    },
  ],
  // @ts-expect-error - Venice-specific parameter
  venice_parameters: {
    enable_web_scraping: true,
  },
});

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

import os
from openai import OpenAI

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

response = client.chat.completions.create(
    model="openai-gpt-55",
    messages=[
        {
            "role": "user",
            "content": "Summarize this post in five bullets: https://venice.ai/blog/how-to-use-venice-api",
        }
    ],
    extra_body={
        "venice_parameters": {
            "enable_web_scraping": True,
        }
    },
)

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

Exemples de code pour les entrées de fichiers

Attachez des PDF, des documents Office, du code et des fichiers texte (jusqu’à 25 Mo) directement à une requête de chat. Voir le guide Entrées de fichiers pour la liste complète des formats.

# Encoder un fichier local en URL de données base64, puis l'envoyer en ligne
FILE_B64=$(base64 q3-report.pdf | tr -d '\n')

curl https://api.venice.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $VENICE_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"model\": \"openai-gpt-55\",
    \"messages\": [
      {
        \"role\": \"user\",
        \"content\": [
          {\"type\": \"text\", \"text\": \"Summarize this report in five bullets and list the main risks.\"},
          {\"type\": \"file\", \"file\": {\"filename\": \"q3-report.pdf\", \"file_data\": \"data:application/pdf;base64,${FILE_B64}\"}}
        ]
      }
    ]
  }"

import OpenAI from "openai";
import { readFile } from "node:fs/promises";

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

const pdf = await readFile("q3-report.pdf");
const fileData = `data:application/pdf;base64,${pdf.toString("base64")}`;

const response = await client.chat.completions.create({
  model: "openai-gpt-55",
  messages: [
    {
      role: "user",
      content: [
        { type: "text", text: "Summarize this report in five bullets and list the main risks." },
        // @ts-expect-error - Venice file input block
        { type: "file", file: { filename: "q3-report.pdf", file_data: fileData } },
      ],
    },
  ],
});

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

import base64
import os
from pathlib import Path
from openai import OpenAI

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

path = Path("q3-report.pdf")
file_data = "data:application/pdf;base64," + base64.b64encode(path.read_bytes()).decode("utf-8")

response = client.chat.completions.create(
    model="openai-gpt-55",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Summarize this report in five bullets and list the main risks."},
                {"type": "file", "file": {"filename": "q3-report.pdf", "file_data": file_data}},
            ],
        }
    ],
)

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

Exemples de code pour Crypto RPC

Transmettez des appels JSON-RPC 2.0 sur 11 chaînes prises en charge avec votre clé Venice ou un portefeuille x402. Voir la référence Crypto RPC pour les chaînes, méthodes et niveaux de crédit.

curl https://api.venice.ai/api/v1/crypto/rpc/ethereum-mainnet \
  -H "Authorization: Bearer $VENICE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_blockNumber",
    "params": [],
    "id": 1
  }'

const response = await fetch(
  "https://api.venice.ai/api/v1/crypto/rpc/base-mainnet",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.VENICE_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify([
      { jsonrpc: "2.0", method: "eth_chainId", params: [], id: 1 },
      { jsonrpc: "2.0", method: "eth_blockNumber", params: [], id: 2 },
    ]),
  }
);

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

import os
import requests

response = requests.post(
    "https://api.venice.ai/api/v1/crypto/rpc/ethereum-mainnet",
    headers={
        "Authorization": f"Bearer {os.environ['VENICE_API_KEY']}",
        "Content-Type": "application/json",
    },
    json={
        "jsonrpc": "2.0",
        "method": "eth_getBalance",
        "params": ["0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045", "latest"],
        "id": 1,
    },
)

print(response.json())

Tarification

Rechargez, stakez ou payez par requête

Approvisionnez un compte avec des crédits, stakez DIEM pour une allocation quotidienne, ou contournez le compte entièrement avec USDC sur Base.

CréditsUSD ou Crypto

Payez à l’usage en USD ou en crypto. Les crédits n’expirent jamais et fonctionnent sur tous les endpoints.

Acheter des crédits

DIEMAllocation quotidienne

Stakez DIEM ou VVV une seule fois et gagnez une allocation d’inférence fixe chaque jour, sans frais par appel.

En savoir plus sur DIEM

x402USDC sur Base

Payez par requête depuis n’importe quel portefeuille Base en USDC. Pas de compte ni de clé API, conçu pour les agents.

Lire le guide x402

Questions ou retours ? Rejoignez-nous sur Discord.

​Une API pour toutes les modalités

​Conçu pour les agents IA

​Modèles populaires

​Outils intégrés pour les modèles de chat