Venice API

Documentação da Venice API — acesso privado e irrestrito a modelos de chat, imagem, áudio e vídeo compatíveis com OpenAI por trás de uma única chave de API.

A API para acesso privado e irrestrito à inteligência.

Chat, imagem, áudio e vídeo compatíveis com OpenAI por trás de uma única chave de API.

Obter uma chave de API →Começar

curl

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

​

Uma API para todas as modalidades

Chat, imagem, áudio, vídeo e embeddings por trás de uma única chave de API.

Chat Completions

Chat compatível com OpenAI com raciocínio, uso de ferramentas e streaming em mais de 100 modelos de texto.

StreamingFerramentasVisão

Ver referência →Geração de imagens

Text-to-image, image-to-image, upscaling e remoção de plano de fundo em modelos fotorrealistas, estilizados e sem censura.

Text-to-imageImage-to-imageUpscale

Ver referência →Áudio

Text-to-speech com mais de 50 vozes multilíngues, mais transcrição speech-to-text para qualquer arquivo de áudio.

TTSTranscrição50+ vozes

Ver referência →Vídeo

Text-to-video, image-to-video e reference-to-video por meio de uma fila de jobs síncrona ou assíncrona.

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

Ver referência →

Mais embeddings, file inputs, ferramentas MCP e pagamentos com carteira. Ver todos os endpoints →

Agentes

​

Feito para agentes de IA

Inferência privada, ferramentas MCP e fluxos de trabalho financiados por carteira para mensageria, programação e agentes onchain.

Apps de agente

Conecte a Venice ao WhatsApp, Telegram, Discord e mais por meio do OpenClaw, Hermes e NanoClaw.

Ver integrações →Agentes de programação

Use Claude Code, Cursor e Codex CLI com modelos Venice para fluxos de codificação privados.

Ver integrações →MCP + Skills

Exponha chat, imagem, vídeo, áudio e embeddings como ferramentas MCP ou skills em runtime.

Ver integrações →

Explore o hub de agentes de IA →

Modelos

​

Modelos populares

Alguns dos modelos mais usados na Venice. Use o ID como seu parâmetro model.

Kimi K2.6Moonshot AI

Raciocínio de fronteira com pesos abertos. Forte em contexto longo e uso de ferramentas a uma fração dos preços de modelos de fronteira.

Contexto de 256K$0.85 / $4.66 por 1MPrivate

kimi-k2-6

Claude Opus 4.7Anthropic

Melhor da categoria para codificação, planejamento e agentes de longo horizonte que precisam manter coerência.

Contexto de 1M$6.00 / $30.00 por 1MAnonymized

claude-opus-4-7

GPT-5.5OpenAI

Inteligência geral de fronteira com contexto de 1M. Padrão forte para chat, RAG e raciocínio em várias etapas.

Contexto de 1M$6.25 / $37.50 por 1MAnonymized

openai-gpt-55

Mais de 250 modelosTexto, imagem, áudio e vídeoNavegar no catálogo →

Ferramentas

​

Ferramentas integradas para modelos de chat

Ative busca na web, anexe arquivos ou consulte uma blockchain com venice_parameters ou um endpoint nativo da Venice.

Web Search

Web Scraping

File Inputs

Crypto RPC

Exemplos de código de Web Search

Adicione busca em tempo real na web com citações a qualquer modelo de texto via enable_web_search.

Curl

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: append parameters directly to the model ID
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?"}]
  }'

Exemplos de código de Web Scraping

Defina enable_web_scraping: true e o modelo buscará e lerá quaisquer URLs na mensagem do usuário antes de responder.

Curl

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)

Exemplos de código de File Inputs

Anexe PDFs, documentos Office, código e arquivos de texto (até 25 MB) diretamente a uma requisição de chat. Veja o guia de File Inputs para a lista completa de formatos.

Curl

# Encode a local file as a base64 data URL, then send it inline
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)

Exemplos de código de Crypto RPC

Faça proxy de chamadas JSON-RPC 2.0 em 11 chains suportadas com sua chave Venice ou uma carteira x402. Veja a referência do Crypto RPC para chains, métodos e níveis de crédito.

Curl

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

Preços

​

Faça uma recarga, faça stake ou pague por requisição

Adicione créditos a uma conta, faça stake de DIEM para um limite diário ou dispense a conta totalmente com USDC na Base.

CréditosUSD ou cripto

Pague conforme o uso em USD ou cripto. Os créditos nunca expiram e funcionam em todos os endpoints.

Comprar créditos

DIEMLimite diário

Faça stake de DIEM ou VVV uma vez e ganhe um limite fixo de inferência todos os dias, sem cobranças por chamada.

Saiba mais sobre o DIEM

x402USDC na Base

Pague por requisição a partir de qualquer carteira na Base em USDC. Sem conta ou chave de API, feito para agentes.

Ler guia do x402

Dúvidas ou feedback? Encontre-nos no Discord.