Agent skill

Venice Models API

by veniceai in veniceai/skills

Documents Venice's model discovery endpoints, GET /models, /models/traits and /models/compatibility_mapping, so an agent can pick a model by capability, constraint or price.

MITAuto-check passedAI & LLM Engineering

Install Venice Models API

skills CLI
$ npx skills add veniceai/skills --skill venice-models -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install veniceai/skills venice-models --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/veniceai/skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/venice-models .claude/skills/venice-models && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
venice-models
GitHub stars
144
Token cost
~4.3k tokens
SKILL.md length
1,491 words
Files
1
Skills in repo
22
Repo updated
First seen
Licence
MIT

At a glance

Documents Venice's model discovery endpoints, GET /models, /models/traits and /models/compatibility_mapping, so an agent can pick a model by capability, constraint or price.

  • Choosing a Venice model at runtime based on its capabilities
  • SKILL.md covers Use when, GET /models, GET /models/traits and GET…, plus 2 more sections
  • Calls curl; reaches api.venice.ai and huggingface.co; needs VENICE_API_KEY
  • Validating a request against a model's prompt length or resolution limits

What it does

Three read-only public GET endpoints expose the catalog. The /models route returns each model's capabilities, constraints and pricing, /models/traits maps names such as default, default_reasoning and highest_quality to model IDs, and /models/compatibility_mapping resolves legacy or third-party IDs to Venice IDs. No API key is needed, but sending one tailors results: privacy settings filter the list, beta accounts see beta models and partner accounts see negotiated rates. An invalid key just gives the public view.

A type parameter, defaulting to text, selects image, video, music, tts, asr, embedding, upscale, inpaint or decision models, and the all and code values work for models and traits but return a 400 on the compatibility route. The skill describes using this to choose models at runtime by features such as vision or function calling, to validate requests against constraints like prompt length or resolution, and to estimate cost per token, image, second or character. The excerpt is cut off in the response field table.

When your agent uses it

  • Choosing a Venice model at runtime based on its capabilities
  • Validating a request against a model's prompt length or resolution limits
  • Estimating cost from per-token, per-image or per-second pricing
  • Resolving a trait or a legacy model name to a current Venice model ID

Example prompts

  • “List the Venice text models that support function calling and show their prices.”
  • “Resolve the default_reasoning trait to a concrete Venice model ID.”
  • “Which Venice image models accept a 16:9 aspect ratio, and what are the resolution limits?”
  • “Map the legacy gpt-4o model name to its Venice equivalent.”

Requirements

  • Network access to api.venice.ai
  • A Venice API key, optional for model discovery

What it can do on your machine

Read from SKILL.md and the folder at commit 5eaeac5. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • curl

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • api.venice.ai
    • huggingface.co

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • VENICE_API_KEY

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Venice Models API loads about 4.3k tokens when it runs. Until then it costs about 121 tokens; SKILL.md has 1,491 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~121
When it runs · the whole SKILL.md, loaded when a task matches
~4.3k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from veniceai/skills at commit 5eaeac5, republished under its MIT licence (© veniceai). 1,491 words, ~4,342 tokens.

Download SKILL.mdSave it as .claude/skills/venice-models/SKILL.md (or your agent's skills folder).
name
venice-models
description
Discover Venice models, their capabilities, constraints, and pricing. Covers GET /models (with the ?type filter - text, image, video, music, tts, asr, embedding, upscale, inpaint, decision, all, code), /models/traits, /models/compatibility_mapping, every ModelResponse field (capabilities, constraints, per-type pricing with promotional rates, uncensored, deprecation, voice-changer and voice-cloning specs), and how to use this to pick the right model programmatically.

Venice Models

Three read-only endpoints for model discovery - all GET, all public:

EndpointReturns
/modelsModel catalog with model_spec (capabilities, constraints, pricing).
/models/traitsTrait → model ID map (e.g. default, default_reasoning, highest_quality).
/models/compatibility_mappingLegacy / third-party model ID → Venice model ID aliases.

Auth is optional. These routes need no API key, so a plain curl works. If you send Authorization: Bearer $VENICE_API_KEY the result is tailored to that caller: a key's modelPrivacy setting filters the list, beta-flagged accounts also see beta models, and partner accounts see their negotiated rates. An invalid key is not rejected - you just get the public view.

?type= values (default text when omitted):

Value/models/models/traits/models/compatibility_mapping
text, image, video, music, tts, asr, embedding, upscale, inpaint, decisionyesyesyes
all (every type)yesyes400
code (text models with capabilities.optimizedForCode: true)yesyes400

Anything else returns 400 { "error": "Invalid request parameters", "details": …, "issues": … }.

music includes long-form audio (songs, sound effects, ElevenLabs narration models) and any voice-changer models. decision lists the typed-judgment models used by POST /decisions (today: jev-latest, flagged betaModel: true) - see venice-decisions.

Use when

  • You need to pick a model at runtime based on capabilities (vision, reasoning, function calling, E2EE, X search, multi-image, …).
  • You need to validate a request against a model's constraints (prompt length, aspect ratio, resolution, steps, durations).
  • You need the current price per million tokens / per image / per second / per million characters to build a cost estimate.
  • You want to resolve a trait (default, default_reasoning, highest_quality) or a legacy alias (gpt-4o) to a concrete Venice model ID.

GET /models

bash
curl "https://api.venice.ai/api/v1/models?type=text"
json
{
  "object": "list",
  "type": "text",
  "data": [
    {
      "id": "zai-org-glm-5-2",
      "object": "model",
      "owned_by": "venice.ai",
      "type": "text",
      "created": 1781568000,
      "context_length": 1000000,
      "model_spec": {
        "name": "GLM 5.2",
        "description": "GLM-5.2 is the next-generation large language model…",
        "availableContextTokens": 1000000,
        "maxCompletionTokens": 131072,
        "privacy": "private",
        "modelSource": "https://huggingface.co/zai-org/GLM-5.2",
        "offline": false,
        "traits": ["default", "function_calling_default"],
        "capabilities": { "supportsReasoning": true, "reasoningEffortOptions": ["none", "high", "max"], "…": "…" },
        "pricing": {
          "input":       { "usd": 1.4,  "diem": 1.4 },
          "cache_input": { "usd": 0.26, "diem": 0.26 },
          "output":      { "usd": 4.4,  "diem": 4.4 }
        }
      }
    }
  ]
}
Top-level ModelResponse fields
FieldNotes
idThe model ID to send as model.
object / owned_byAlways "model" / "venice.ai".
typeOne of the 10 model types above.
createdUnix seconds - release date on the Venice API.
context_lengthText models only. OpenAI-compatible mirror of model_spec.availableContextTokens.
discount_to_userReseller-only (0 < x < 1). Returned only to the reselling partner whose agreement it belongs to and omitted for other callers - treat absent as no discount.
model_specEverything below.
model_spec - common fields
FieldUse
name, description, modelSourceDisplay name, blurb, upstream URL (description / modelSource may be absent).
privacyprivate (zero data retention) or anonymized (third-party provider; not tied to your identity).
offlinetrue ⇒ requests return 503 "The model is temporarily offline". Skip it.
traitsTrait names this model currently holds (may be []).
uncensoredPresent and true only for models Venice classifies as uncensored (all modalities). Absent otherwise - never false. Upstream providers may still filter.
betaModelModel is in beta status (still callable).
betaModel is restricted to beta-access accounts. Only appears in lists returned to such accounts.
regionRestrictionsCountry codes where the model is blocked (the OpenAPI description reads "intended to be available", but requests are rejected from the listed countries). Those requests get 403 "The specified model is unavailable in <country>…". Absent on unrestricted models.
deprecation{ autoRemap, date, removesAt, replacementModelId?, startsAt? } - present only when retirement is scheduled. The model drops out of /models at removesAt; autoRemap: true means Venice may remap requests for this ID to replacementModelId instead of returning an error.
model_setsText, image and video only. Curation tags such as venice_recommendations, featured, and for video audio, uncensored, high_resolution, fast, … (served live but not declared in the OpenAPI schema).
model_spec.capabilities - text models
FlagMeaning
optimizedForCodeTuned for coding tasks (drives ?type=code).
quantizationfp4 / fp8 / fp16 / bf16 / int8 / int4 / not-available.
supportsFunctionCallingtools are allowed.
supportsResponseSchemaHonors response_format: { type: "json_schema" }.
supportsReasoningModel emits reasoning.
supportsReasoningEffortHonors reasoning_effort / reasoning.effort. When true, also reasoningEffortOptions (subset of none, minimal, low, medium, high, xhigh, max - none means reasoning can be turned off) and defaultReasoningEffort.
supportsVisionAccepts image_url parts.
supportsMultipleImages + maxImagesMore than one image per request; maxImages is the model's advertised limit. Chat hard-caps every model at 10 images per message.
supportsVideoInput + maxVideosAccepts video_url parts; maxVideos present on some models.
supportsAudioInputAccepts input_audio parts.
supportsWebSearchvenice_parameters.enable_web_search - currently true on every text model.
supportsXSearchxAI native web + X search via venice_parameters.enable_x_search.
supportsLogProbsHonors logprobs / top_logprobs.
supportsTeeAttestationRuns in a TEE; verify with GET /tee/attestation / /tee/signature.
supportsE2EEEnd-to-end encrypted inference (requires TEE).
model_spec.constraints and type-specific fields
  • Text - constraints is optional (only a handful of models carry it): temperature.default, top_p.default, optional {frequency,presence,repetition}_penalty.default.
  • Image - constraints: promptCharacterLimit, widthHeightDivisor, steps.{default,max}, optional aspectRatios[] + defaultAspectRatio, optional resolutions[] + defaultResolution, optional qualities[] + defaultQuality (models that accept quality), optional maxStyleReferences + supportsStyleReferenceStrength. Alongside: supportsStyleReferences, plus supportsWebSearch and supportsOptimizePromptThinking (served live, not in the OpenAPI schema).
  • Inpaint / edit - constraints: aspectRatios[], promptCharacterLimit, combineImages, optional maxInputImages, singleImageAspectRatio (if false, single-image edits keep input dimensions and ignore aspect_ratio), optional resolutions[]/defaultResolution, qualities[]/defaultQuality. Alongside: supportsOptimizePromptThinking.
  • Video - constraints: model_type (text-to-video / image-to-video / video), aspect_ratios[], resolutions[], durations[] (e.g. "5s"; most upscale and video-to-video models list "Auto", meaning the source length — omit duration for them), audio, audio_configurable, audio_input, per_reference_audio, video_input, optional prompt_character_limit (default 2500), optional reference_image_min_short_side_pixels, reference_image_min_aspect_ratio, reference_image_max_aspect_ratio, and a topaz block (models, sliders, selects, no_upscale_models, h264_output, prompt) on enhancement models only. The audio_input … reference_image_* keys are served live but not declared in the OpenAPI schema.
  • TTS (top level of model_spec) - voices[], default_format, supported_formats[] (an explicit format outside this list is rejected), supports_custom_voice_id, and voice_cloning { mode: "zero_shot" | "persistent", accepted_formats[], min_sample_seconds, retention_days } on models whose cloning is open to you (use with POST /audio/voices, see venice-audio-speech). Per-model toggles like prompt / temperature / top_p support are not exposed here - use the per-model table in venice-audio-speech as the support matrix (the published schema text is incomplete).
  • Music / audio generation (top level) - supports_lyrics, lyrics_required, supports_force_instrumental, supports_lyrics_optimizer (served live, not in the OpenAPI schema), supports_loop, supports_custom_voice_id, supports_language_code, supports_speed, supported_formats[], default_format, prompt_character_limit, min_prompt_length, optional lyrics_character_limit, duration_options[], min_duration / max_duration / default_duration, voices[] / default_voice, default_speed / min_speed / max_speed.
  • Voice changer (music models with voice_changer: true) - adds supports_background_noise_removal, supports_seed, accepted_audio_formats[], max_source_audio_duration_seconds. These run on /audio/voice-changer/*, not /audio/queue - see venice-audio-voice-changer. No voice-changer model is publicly listed today; check ?type=music for voice_changer: true before relying on it.
  • Embedding (top level) - embeddingDimensions, maxInputTokens, supportsCustomDimensions (present only when true).
  • Decision (top level) - maxStateTokens (state + longest question), maxTotalTokens (state + all questions).
  • ASR / upscale - no extra fields beyond the common ones and pricing.
Show full SKILL.md (511 more words)Show less
model_spec.pricing - by type

Every price is { usd, diem }; today diem always equals usd. Prices already include any promotional discount active for the calling account (some promos are tier-gated, so anonymous and Pro callers can see different numbers) - quote from the same credentials you will bill with.

  • Text / embedding / decision - input and output per 1 000 000 tokens, optional cache_input (cache reads), cache_write (cache creation, e.g. Anthropic), and extended { context_token_threshold, input, output, cache_input?, cache_write? }. When input tokens exceed the threshold, extended rates apply to the entire request.
  • Image - generation (flat per image) or resolutions.<1K|2K|4K>; optional quality.<resolution>.<low|medium|high>; always an upscale.{2x,4x} block (the shared upscale price, not a sign that this model upscales, and not promo-discounted).
  • Upscale (upscaler) - same shape as image: generation + upscale.{2x,4x}.
  • Inpaint / edit - inpaint per edit, optional resolutions.*, optional inputImages { included, additional } (surcharge per input image beyond included), optional quality.*.
  • Video - no pricing on /models. Use POST /video/quote (see venice-video).
  • Music - exactly one of generation (per job), durations.<ceiling_seconds> { usd, diem, min_seconds, max_seconds }, per_second, or per_thousand_characters. Use POST /audio/quote for the exact price.
  • TTS - input per 1 000 000 input characters.
  • ASR - per_audio_second.

Crypto RPC pricing is not in /models - see venice-crypto-rpc.

GET /models/traits

bash
curl "https://api.venice.ai/api/v1/models/traits?type=text"
json
{
  "object": "list",
  "type": "text",
  "data": {
    "default": "zai-org-glm-5-2",
    "function_calling_default": "zai-org-glm-5-2",
    "default_reasoning": "kimi-k3",
    "default_code": "deepseek-v4-pro-0813",
    "default_vision": "qwen-3-8-27b",
    "most_intelligent": "grok-4-7",
    "most_uncensored": "venice-uncensored-1-2"
  }
}

Possible trait keys: default, fastest, most_uncensored, eliza-default (any type), default_code, default_reasoning, default_vision, function_calling_default, most_intelligent (text), highest_quality (image). A key only appears while some model holds it - fastest is currently unassigned for text. Today only text and image (and the all / code filters built from them) return non-empty maps. ?type=all merges every type into one map, so keys shared across types collide - e.g. default resolves to an image model there. The values above are a snapshot; resolve them at runtime.

A trait name can also be sent directly as model (e.g. "model": "default_reasoning") and Venice resolves it per request.

GET /models/compatibility_mapping

bash
curl "https://api.venice.ai/api/v1/models/compatibility_mapping?type=text"
json
{
  "object": "list",
  "type": "text",
  "data": {
    "gpt-4o": "llama-3.3-70b",
    "gpt-4.1": "qwen3-235b-a22b-instruct-2507",
    "claude-3-5-sonnet-20241022": "llama-3.3-70b",
    "qwen3-235b": "qwen3-235b-a22b-thinking-2507"
  }
}

Keys are legacy OpenAI / Anthropic / older Venice IDs; values are the Venice model each one resolves to. ?type=embedding currently maps text-embedding-ada-002 → text-embedding-bge-m3; other types are empty. Like traits, an alias can be sent directly as model. Useful when porting code that hard-codes old OpenAI IDs - but check the target's capabilities, since the mapping is by ID only.

Common patterns

Pick a vision + reasoning model at runtime
ts
const base = 'https://api.venice.ai/api/v1'
const list = await fetch(`${base}/models?type=text`).then(r => r.json())
const match = list.data.find((m: any) =>
  m.model_spec.capabilities.supportsVision &&
  m.model_spec.capabilities.supportsReasoning &&
  !m.model_spec.offline &&
  !m.model_spec.deprecation
)
Validate an image request before submit
ts
const spec = (await fetch(`${base}/models?type=image`).then(r => r.json()))
  .data.find((m: any) => m.id === myModel)!.model_spec

const { widthHeightDivisor, promptCharacterLimit, aspectRatios } = spec.constraints
if (prompt.length > promptCharacterLimit) throw new Error('prompt too long')
if (width % widthHeightDivisor !== 0) throw new Error('width not divisible')
if (aspectRatios && !aspectRatios.includes(myAspect)) throw new Error('bad aspect')
Estimate LLM cost
ts
// textSpec = model_spec of a text model from /models?type=text
// inputTokens = total prompt tokens, including cachedTokens
const p = textSpec.pricing
const tier = p.extended && inputTokens > p.extended.context_token_threshold ? p.extended : p
const cacheRate = tier.cache_input?.usd ?? tier.input.usd
const cost =
  ((inputTokens - cachedTokens) / 1_000_000) * tier.input.usd +
  (cachedTokens / 1_000_000) * cacheRate +
  (outputTokens / 1_000_000) * tier.output.usd

Cache-write tokens (models with cache_write) are billed at that rate instead of input.

Gotchas

  • The catalog changes - cache for minutes, not days. Model IDs in this skill are a snapshot; always confirm against /models.
  • Omitting ?type returns text only. Use ?type=all for everything.
  • model_spec.pricing is always absent for video and can be absent for any model without a published price - guard against undefined.
  • regionRestrictions lists blocked countries, not allowed ones.
  • uncensored is omitted rather than false - test with === true.
  • Traits and aliases differ by type - there is no global default; always pass ?type=....
  • An API key restricted to private models (modelPrivacy: PRIVATE_TEXT / PRIVATE_ONLY) sees a filtered list; unauthenticated calls see everything public.
  • Some fields are served live but missing from the OpenAPI ModelResponse schema (model_sets, image supportsWebSearch, image and inpaint supportsOptimizePromptThinking, music supports_lyrics_optimizer, several video constraint keys). Strict generated clients may drop them.

© veniceai, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/venice-models of veniceai/skills.

Open the folder on GitHubat commit 5eaeac5

Compare with similar skills

Venice Models API next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Venice Models API compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Venice Models API this skillveniceai/skills144—~4.3kAutomated safety check: PassMIT
OpenCodex Proxy Operationslidge-jun/opencodex17k—~3.1kAutomated safety check: PassMIT
9Router AI Gateway Setupdecolua/9router31k—~744Automated safety check: PassMIT
9Router Chat Completionsdecolua/9router31k—~635Automated safety check: PassMIT
Using Ccproxy Inspectorstarbaser/ccproxy350—~2.7kAutomated safety check: PassCustom licence
Pinme LLMglitternetwork/pinme3.8k—~2.8kAutomated safety check: PassMIT

Similar skills

  • OpenCodex Proxy Operations

    lidge-jun/opencodex

    Operates an opencodex (`ocx`) proxy: finds CLI tasks offline, checks local configuration, and manages accounts, providers, models, routing and usage reports.

    17k GitHub stars~3.1k tokensUpdated today
    AI & LLM EngineeringAuto-check passed
  • Sets up access to the 9Router AI gateway, an OpenAI-compatible REST endpoint for chat, images, speech, embeddings, web search and web fetch, and indexes its capability skills.

    31k GitHub stars~744 tokensUpdated 2 days ago
    AI & LLM EngineeringAuto-check passed
  • Sends chat and code-generation requests through a 9Router gateway using OpenAI or Anthropic message formats, with streaming and auto-fallback combos.

    31k GitHub stars~635 tokensUpdated 2 days ago
    AI & LLM EngineeringAuto-check passed
  • Using Ccproxy Inspector

    starbaser/ccproxy

    Operates the ccproxy inspector MITM system for intercepting, inspecting, and transforming LLM API traffic.

    350 GitHub stars~2.7k tokensUpdated 2 mo ago
    AI & LLM EngineeringAuto-check passed
  • Pinme LLM

    glitternetwork/pinme

    A skill your agent uses when a PinMe project (Worker TypeScript) needs to call OpenRouter-backed LLM APIs, including models, chat/completions, streaming, or OpenRouter web search.

    3.8k GitHub stars~2.8k tokensUpdated 28 days ago
    AI & LLM EngineeringAuto-check passed
  • Using Ccproxy API

    starbaser/ccproxy

    Guides users through ccproxy as an OpenAI-compatible and Anthropic-compatible LLM API server with SDK integration, OAuth authentication, sentinel key substitution, model routing, and troubleshooting.

    350 GitHub stars~4k tokensUpdated 2 mo ago
    AI & LLM EngineeringAuto-check passed

More from veniceai/skills

All 22 skills in this repo
  • Picks which Venice text model to call for a prompt based on privacy tier, input modality, capabilities and cost, and decides when to escalate from a local agent.

    144 GitHub stars~5.2k tokensUpdated 4 days ago
    Auto-check passed
  • Venice API Keys

    veniceai/skills

    Manages Venice API keys through the /api_keys endpoints: create, list, update and revoke keys, set spending limits, and read rate limits.

    144 GitHub stars~3.8k tokensUpdated 4 days ago
    Auto-check passed
  • Venice API Overview

    veniceai/skills

    High-level map of the Venice.ai API: base URL, auth modes per endpoint, endpoint categories, response headers, pricing model, error shape and versioning.

    144 GitHub stars~3.5k tokensUpdated 4 days ago
    Auto-check passed
  • Venice Audio Music

    veniceai/skills

    Async music, sound-effect and long-form voice generation via Venice.

    144 GitHub stars~3.1k tokensUpdated 4 days ago
    Auto-check passed
  • Venice Audio Speech

    veniceai/skills

    Generate speech from text via POST /audio/speech, and clone a voice via POST /audio/voices.

    144 GitHub stars~3.6k tokensUpdated 4 days ago
    Auto-check passed
  • Transcribe audio files to text via POST /audio/transcriptions.

    144 GitHub stars~1.7k tokensUpdated 4 days ago
    Auto-check passed

Works with

Questions about Venice Models API

What does Venice Models API do?

Documents Venice's model discovery endpoints, GET /models, /models/traits and /models/compatibility_mapping, so an agent can pick a model by capability, constraint or price. Three read-only public GET endpoints expose the catalog. The /models route returns each model's capabilities, constraints and pricing, /models/traits maps names such as default, default_reasoning and highest_quality to model IDs, and /models/compatibility_mapping resolves legacy or third-party IDs to Venice IDs.

When should I use Venice Models API?

Venice Models API fits situations like: choosing a Venice model at runtime based on its capabilities; validating a request against a model's prompt length or resolution limits; estimating cost from per-token, per-image or per-second pricing; resolving a trait or a legacy model name to a current Venice model ID.

How do I install Venice Models API in Claude Code?

Run `npx skills add veniceai/skills --skill venice-models -a claude-code`. Or copy the skill folder (skills/venice-models in veniceai/skills) into .claude/skills/venice-models in your project. Claude Code loads it when a task matches its description.

How do I install Venice Models API in Codex?

Run `npx skills add veniceai/skills --skill venice-models -a codex`. Or copy the skill folder (skills/venice-models in veniceai/skills) into .agents/skills/venice-models in your project. Codex loads it when a task matches its description.

Can I use Venice Models API in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add veniceai/skills --skill venice-models -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/venice-models, .gemini/skills/venice-models, .github/skills/venice-models and .opencode/skills/venice-models in your project.

What does Venice Models API need to run?

Going by SKILL.md and its folder, Venice Models API needs the command-line tools its instructions call (curl) and credentials named VENICE_API_KEY. Our summary lists: Network access to api.venice.ai; A Venice API key, optional for model discovery.

Does Venice Models API access the network?

SKILL.md names 2 domains. In commands or code: api.venice.ai and huggingface.co; the agent is likely to contact these when it follows the instructions. This is read from the text; nothing was executed.

Is Venice Models API safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Venice Models API use?

Venice Models API is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Venice Models API use?

About 4.3k tokens (SKILL.md is roughly 17k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Venice Models API?

Skills that share tags, products or a category with Venice Models API: OpenCodex Proxy Operations (lidge-jun/opencodex, 17k stars), 9Router AI Gateway Setup (decolua/9router, 31k stars), 9Router Chat Completions (decolua/9router, 31k stars) and Using Ccproxy Inspector (starbaser/ccproxy, 350 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Venice Models API?

veniceai (a GitHub organization) maintains it in veniceai/skills, which has 144 GitHub stars. The repository holds 22 skills in this directory. The repository was last updated on October 5, 2026.

Source: veniceai/skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.