Novita Ai

Novita AI

The AI-Native Cloud for builders and agents: run models, scale GPUs, and build AI agents on one platform.

This file is the agent route. It must work when installed as a skill and when read directly from: https://raw.githubusercontent.com/novitalabs/novita-skills/main/skills/novita-ai/SKILL.md

Rules

• Use NOVITA_API_KEY; never paste secrets into source or answers.
• Use NOVITA_MODEL or the model already selected by the user/application.
• Do not recommend or invent a default model. If none is selected, list models or ask the user to choose.
• Verify dynamic data live before giving hard values: models, pricing, rate limits, quota, latency, GPU inventory, and sandbox limits.
• Pick one route first. Read more than one reference only when the task spans products.
• In raw-read mode, fetch the matching raw reference URL from the route table.
• Return runnable code or commands with explicit placeholders such as <MODEL_NAME>, <TASK_ID>, and <INPUT_FILE>.
• Use trusted local media files for image, video, and audio inputs unless the user explicitly provides a safe URL.

Constants

Route Table

Model Selection

Use this order:

1. User-provided model. 2. Existing project config or NOVITA_MODEL. 3. Live catalog query, then ask the user or choose only when the user gave selection criteria.

curl https://api.novita.ai/openai/v1/models \
  -H "Authorization: Bearer $NOVITA_API_KEY"

Minimal LLM Call

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.novita.ai/openai",
    api_key=os.environ["NOVITA_API_KEY"],
)

response = client.chat.completions.create(
    model=os.environ["NOVITA_MODEL"],
    messages=[{"role": "user", "content": "Hello"}],
    max_tokens=512,
)

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

curl https://api.novita.ai/openai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $NOVITA_API_KEY" \
  -d '{
    "model": "'"$NOVITA_MODEL"'",
    "messages": [{"role": "user", "content": "Hello"}],
    "max_tokens": 512
  }'

Async Tasks

Image and video APIs often return task_id. Poll results:

curl "https://api.novita.ai/v3/async/task-result?task_id=<TASK_ID>" \
  -H "Authorization: Bearer $NOVITA_API_KEY"

Agent Sandbox

Use Sandbox for isolated code execution, file operations, templates, long-running agent environments, and E2B-compatible workflows. Handle common Sandbox tasks here; use novita-sandbox only for deeper CLI detail.

SDK Baseline

pip install novita-sandbox
export NOVITA_API_KEY=<YOUR_API_KEY>

from novita_sandbox.code_interpreter import Sandbox

sandbox = Sandbox.create()
execution = sandbox.run_code("print('hello world')")
print(execution.logs)
sandbox.kill()

Generate JavaScript/TypeScript equivalents when the user is working in Node.js.

CLI Baseline

Check Node.js and install or update the CLI:

if ! command -v node >/dev/null 2>&1; then
  echo "Install Node.js first"
elif ! command -v novita-sandbox-cli >/dev/null 2>&1; then
  npm install -g novita-sandbox-cli@beta
else
  novita-sandbox-cli --version
fi

Authenticate when needed:

novita-sandbox-cli auth info || novita-sandbox-cli auth login

CLI Workflows

# Template
novita-sandbox-cli template init
novita-sandbox-cli template build -n <TEMPLATE_NAME>
novita-sandbox-cli template list

# Sandbox lifecycle. Use --detach inside AI agents; interactive terminals usually fail there.
novita-sandbox-cli sandbox create <TEMPLATE_ID> --detach
novita-sandbox-cli sandbox list
novita-sandbox-cli sandbox logs <SANDBOX_ID> -f
novita-sandbox-cli sandbox metrics <SANDBOX_ID> -f
novita-sandbox-cli sandbox clone <SANDBOX_ID> --count <N>
novita-sandbox-cli sandbox commit <SANDBOX_ID> --alias <ALIAS>
novita-sandbox-cli sandbox kill <SANDBOX_ID>

# Deploy and invoke an agent. Pass env vars explicitly; sandbox processes do not inherit local shell env.
novita-sandbox-cli agent configure -n <AGENT_NAME> -e <ENTRYPOINT>
novita-sandbox-cli agent launch
novita-sandbox-cli agent invoke '{"prompt":"hello"}' --stream --env NOVITA_API_KEY=$NOVITA_API_KEY

For exact flags, template versioning, E2B compatibility, pricing, and quota behavior, read the Sandbox route in the table above.

Error Defaults

• 401 / 403: check key, account status, and Authorization: Bearer ....
• 404 / model not found: verify exact model ID from the live catalog.
• 429: reduce concurrency, back off, inspect rate limits and account tier.
• Insufficient credits: check billing and balance.
• Long-running media: use async polling or webhooks.

Novita AI Audio API Reference

Security: All audio inputs should come from trusted, local sources only. Verify the origin of any audio data before processing.

Table of Contents

• MiniMax TTS (Speech-02-HD)
• MiniMax TTS Variants
• GLM TTS
• GLM ASR (Speech-to-Text)
• Voice Cloning
• Fish Audio

MiniMax TTS

POST https://api.novita.ai/v3/minimax-speech-02-hd — Synchronous (streaming supported)

Request

voice_setting

System Voices

audio_setting

Advanced Features

Timbre blending (alternative to voice_id):

{
  "timbre_weights": [
    {"voice_id": "Calm_Woman", "weight": 70},
    {"voice_id": "Deep_Voice_Man", "weight": 30}
  ]
}

Voice modification:

{
  "voice_modify": {
    "pitch": 50,
    "intensity": 30,
    "timbre": 0,
    "sound_effects": "spacious_echo"
  }
}

Effects: spacious_echo, auditorium_echo, lofi_telephone, robotic

Pronunciation dictionary:

{
  "pronunciation_dict": {"tone": ["omg/oh my god", "API/A-P-I"]}
}

Response

Non-streaming: returns audio data in the response body

Streaming (SSE): data: {"audio": "<hex>", "status": 1} ... data: {"status": 2}

MiniMax TTS Variants

All share the same parameter structure as Speech-02-HD.

GLM TTS

POST https://api.novita.ai/v3/glm-tts — Synchronous (returns binary audio)

Optimized for Chinese, low latency.

Request

Voices

Response

Binary audio data. Recommended sample rate: 24000 Hz.

Pipe directly to file:

curl ... --output speech.wav

GLM ASR

Endpoint: POST /v3/glm-asr (synchronous)

Parameters:

• file (string, required) — encoded audio data from a local file. Supported formats: wav, mp3. Max 25 MB, max 30 seconds.
• prompt (string, optional) — previous transcription context for continuity, max 8000 characters
• hotwords (array, optional) — domain-specific vocabulary list, max 100 words

Returns a text field with the transcribed content.

Voice Cloning

MiniMax Voice Cloning

Endpoint: POST /v3/minimax-voice-cloning

Parameters:

• audio (string) — reference audio data from a local file you own or have permission to use
• text (string) — text to generate with the cloned voice
• model (string) — use "speech-02-hd"
• accuracy (number) — cloning accuracy level

GLM TTS Voice Clone

Asynchronous endpoint — returns task_id for polling.

Fish Audio

Fish Audio TTS

Asynchronous endpoint — returns task_id. Supports custom voices from the Fish Audio voice library.

Fish Audio Voice Cloning

Asynchronous endpoint — create custom voices from audio samples.

Common Issues & FAQ

Last verified: 2026-02-09

Table of Contents

• API Issues
• Billing Issues
• GPU Instance Issues
• Sandbox Issues
• Integration Issues
• Get Help

API Issues

Authentication Failed

• Ensure header format: Authorization: Bearer <API_KEY> (not just the key)
• Check API key is valid at https://novita.ai/settings/key-management
• API keys can be disabled or deleted - verify status

Model Not Found

• Model names are case-sensitive
• Format: provider/model-name
• Query available models: GET https://api.novita.ai/openai/v1/models

Rate Limit Exceeded

• Rate limits vary by account tier and model
• Confirm current limits in console/docs before tuning client behavior
• Use exponential backoff for retries
• Respect 429 responses and Retry-After headers
• Contact support for higher limits

Request Timeout

• Use streaming mode for long outputs: "stream": true
• Reduce max_tokens if response is too long
• Check https://status.novita.ai for service status

Billing Issues

Insufficient Balance

• Check balance at https://novita.ai/billing
• Enable Auto Top-up
• Set Low Balance Alert

Payment Failed

Common causes:

• Card issuer rejection (check with bank)
• Card expired or frozen
• Insufficient card balance
• Risk control (try different card)

GPU Instance Issues

Instance Won't Restart

After stopping, resources may be preempted. Solution: 1. Save image of your instance 2. Create new instance from saved image 3. Use Network Volume for persistent data

Storage Types

Check GPU Usage

pip install py3nvml
py3smi

(Use py3smi instead of nvidia-smi in containers)

CUDA Version

CUDA is backward compatible. If you need CUDA 12.1, any version >= 12.1 works.

Sandbox Issues

Sandbox Timeout

• Idle timeout varies by current sandbox settings/policy
• Use keep_alive=True for long-running tasks
• Consider using persistence/snapshot features

Command Execution Failed

• Check if required packages are installed
• Verify file paths are correct
• Check sandbox logs for errors

Integration Issues

OpenAI SDK Not Working

Use this baseline client configuration:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.novita.ai/openai",  # Note: /openai suffix
    api_key=os.environ["NOVITA_API_KEY"],
)

LangChain Integration

import os
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    base_url="https://api.novita.ai/openai",
    api_key=os.environ["NOVITA_API_KEY"],
    model=os.environ["NOVITA_MODEL"],
)

Get Help

• Discord: https://discord.gg/YyPRAzwp7P
• Email: support@novita.ai
• Status: https://status.novita.ai
• Full FAQ: https://novita.ai/docs/guides/faq

Novita AI GPU Cloud API Reference

Base: https://api.novita.ai/gpu-instance/openapi/v1

Table of Contents

• Instance Management
• Products & Clusters
• Templates
• Network Storage
• Serverless Endpoints
• Account & Billing

Instance Management

Create Instance

POST /gpu/instance/create

Create CPU Instance

POST /cpu/instance/create — Same structure, for CPU-only workloads.

List Instances

GET /gpu/instance/list?pageSize=20&pageNum=1

Optional filters: name, status

Get Instance

GET /gpu/instance/get?instanceId=X

Instance Actions

Instance Metrics

GET https://api.novita.ai/openapi/v1/metrics/gpu/instance?instanceId=X&interval=5m

Products & Clusters

List GPU Products

GET /products

Optional filters: gpuNum, productName, billingMethod

Returns available GPU types with pricing, VRAM, and availability.

List CPU Products

GET /cpu/products

Optional filter: productName

List Clusters (Data Centers)

GET /clusters

Returns available regions/data centers.

Templates

Reusable instance configurations. Template CRUD is free — safe for testing.

Create Template

POST /template/create

{
  "template": {
    "name": "my-template",
    "type": "private",
    "channel": "private",
    "image": "pytorch/pytorch:latest",
    "rootfsSize": 20,
    "startCommand": "python main.py",
    "minCudaVersion": "12.0",
    "envs": [{"key": "DEBUG", "value": "1"}]
  }
}

List Templates

GET /templates?channel=private&pageSize=20&pageNum=1

Channels: official, community, private

Get Template

GET /template?templateId=X

Update Template

POST /template/update — Same structure as create, with template.Id field.

Delete Template

POST /template/delete — {templateId}

Network Storage

Persistent storage that can be attached to GPU instances.

Create Storage

POST /networkstorage/create

{"clusterId": "xxx", "storageName": "my-storage", "storageSize": 100}

List Storage

GET /networkstorages

Delete Storage

POST /networkstorage/delete — {id}

Serverless Endpoints

Auto-scaling GPU endpoints for inference workloads.

Create Endpoint

POST /endpoint/create

{
  "endpoint": {
    "name": "my-endpoint",
    "appName": "my-app",
    "workerConfig": {
      "minNum": 0,
      "maxNum": 3,
      "freeTimeout": 300,
      "maxConcurrent": 10,
      "gpuNum": 1
    },
    "ports": [{"containerPort": 8080, "protocol": "TCP"}],
    "policy": {"type": "queue", "value": 5},
    "image": "my-inference-image:latest"
  }
}

List Endpoints

GET /endpoint/list?pageSize=20&pageNum=1

Get Endpoint

GET /endpoint/get?id=X

Update Endpoint

POST /endpoint/update — Partial update with {id, workerConfig, ports, policy, image}.

Delete Endpoint

POST /endpoint/delete — {name}

Endpoint Limits

GET /endpoint/limit — Query account-level endpoint limits.

Account & Billing

Different base path: https://api.novita.ai/openapi/v1/billing

Get Balance

GET /openapi/v1/billing/balance/detail

Response fields: availableBalance, cashBalance, creditLimit, outstandingInvoices

All amounts in units of 0.0001 USD (divide by 10000 for dollars).

Monthly Bill

GET /openapi/v1/billing/monthly/bill

Usage-Based Billing

GET /openapi/v1/billing/bill/list

Query params: cycleType (Hour/Day/Week/Month), productCategory (summary/gpu/llm/serverless/cloud_storage/gen_api), startTime, endTime

Fixed-Term Billing

GET /openapi/v1/billing/fixed-term/bill

GPU Guide

Novita AI offers two GPU products for different use cases.

Table of Contents

• Product Comparison
• GPU Instance
• Serverless GPU
• Common Tasks
• Resources

Product Comparison

---

GPU Instance

Dedicated virtual machines with full GPU control.

Features

• Fast startup: Instances start in seconds
• Built-in templates: Pre-configured for common AI tasks
• Global regions: Deploy close to users
• Free storage: Free-tier allocation depends on current product policy
• Per-second billing: Pay only for running time
• Cost profile: Can be cost-effective versus major cloud providers, depending on workload and region

Storage Types

Recommendation: Use Network Volume for data that must persist across instance restarts.

Quick Start

1. Create Instance

1. Go to https://novita.ai/gpu-instance/console/explore 2. Choose a GPU template (e.g., PyTorch, ComfyUI, Ollama) 3. Select GPU type and region 4. Click "Create"

2. Connect

SSH:

ssh root@<instance-ip> -p <port>

Web Terminal: Available in console UI

JupyterLab: Many templates include JupyterLab at port 8888

3. Save Image

Before stopping, save your environment: 1. Go to instance details 2. Click "Save Image" 3. Use saved image to create new instances

Pricing

Compute

• Billed per-second, settled hourly
• Billing starts at "Pulling" status
• Pricing varies by region, GPU type, and product policy
• Always check live pricing: https://novita.ai/gpu-instance/pricing

Storage

• Storage pricing can change; verify current rates in the pricing page above

---

Serverless GPU

Fully managed GPU endpoints that auto-scale.

Features

• Auto-scaling: Scale to zero when idle, scale up on demand
• Pay per request: Only pay for actual compute time
• No infrastructure: No VM management
• REST API: Simple HTTP endpoints

Quick Start

1. Create Endpoint

1. Go to https://novita.ai/gpus-console/serverless 2. Prepare a Docker container image with your model/code 3. Configure:

• GPU type
• Min/max replicas
• Timeout settings

4. Deploy

2. Call Endpoint

curl -X POST https://api.novita.ai/serverless/<endpoint-id>/run \
  -H "Authorization: Bearer $NOVITA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"input": {"prompt": "Hello"}}'

3. Async Requests

For long-running tasks, first submit the async job, then poll the status endpoint.

curl -X POST https://api.novita.ai/serverless/<endpoint-id>/runsync \
  -H "Authorization: Bearer $NOVITA_API_KEY" \
  -d '{"input": {...}}'

curl https://api.novita.ai/serverless/<endpoint-id>/status/<job-id> \
  -H "Authorization: Bearer $NOVITA_API_KEY"

Scaling Configuration

---

Common Tasks

Check GPU Usage

pip install py3nvml
py3smi  # Use instead of nvidia-smi in containers

CUDA Compatibility

CUDA is backward compatible. If you need CUDA 12.1, any version >= 12.1 works.

Troubleshooting

• Check "System Logs" and "Instance Logs" in console
• For save image failures, verify container registry auth
• Contact support: https://discord.gg/YyPRAzwp7P

---

Resources

• GPU Console: https://novita.ai/gpu-instance/console
• Serverless Console: https://novita.ai/gpus-console/serverless
• Pricing: https://novita.ai/gpu-instance/pricing
• Full Docs: https://novita.ai/docs/guides/gpu-instance-overview

Last verified: 2026-02-09

Novita AI Image API Reference

All image endpoints use Bearer token authentication. Images are passed as encoded data from local files.

Security

• Only use images from trusted, local sources
• Verify the origin of all image data before processing
• Enable NSFW detection for user-facing applications

Image Generation

FLUX.1 Schnell (synchronous)

POST /v3beta/flux-1-schnell

Synchronous text-to-image endpoint. Returns images directly in the response.

Required fields: prompt (max 1024 chars), width (64-2048), height (64-2048), image_num (1-8), steps (1-100), seed.

Optional: response_image_format (png, webp, jpeg).

Verify current pricing at https://novita.ai/pricing before quoting costs.

FLUX Kontext (asynchronous)

Three tiers available at /v3/async/flux-1-kontext-dev, -pro, and -max.

Supports text-to-image and image editing with up to 4 encoded reference images from local files. Required: prompt. Optional: images (array of encoded image data), size, num_inference_steps, guidance_scale, num_images, seed, output_format.

Stable Diffusion (asynchronous)

Text-to-image at POST /v3/async/txt2img. Image-to-image at POST /v3/async/img2img.

The request body wraps parameters in a request object. Required fields for txt2img: model_name (e.g. sd_xl_base_1.0.safetensors), prompt, width (128-2048), height (128-2048), image_num (1-8), steps (1-100), guidance_scale (1-30), sampler_name.

Optional: negative_prompt, seed, loras (max 5, with model_name and strength), embeddings, hires_fix, refiner.

For img2img, additionally requires the source image data and a strength value (0-1).

Samplers: Euler a, Euler, LMS, Heun, DPM2, DPM++ 2M, DPM++ SDE, DPM++ 2M Karras, DPM++ SDE Karras, DDIM, PLMS, UniPC, and others.

Other Generation Models

Additional async endpoints at /v3/async/{model}: Seedream (seedream-3.0, seedream-4.0, seedream-4.5, seedream-5.0-lite), FLUX 2 (flux-2-dev, flux-2-flex, flux-2-pro), Qwen Image, Hunyuan Image 3, GLM Image. All return a task_id for polling.

Image Editing

Synchronous Endpoints

These endpoints accept an encoded image and return the result directly.

Common parameters: All accept image data (encoded, max 16 megapixels, max 30 MB). Replace Background and Outpainting also accept a text prompt. Cleanup requires a mask image. Merge Face requires both a face source and a target image.

Asynchronous Endpoints

These return a task_id for polling.

Inpainting uses the same request structure as Stable Diffusion txt2img, with additional image and mask fields.

Task Result Polling

GET /v3/async/task-result with query parameter task_id.

The response includes a task status (QUEUED, PROCESSING, SUCCEED, or FAILED) and, on success, an images array with time-limited download links.

Extra Options

Many endpoints support an extra object with:

• Response image format (png, webp, jpeg)
• NSFW detection toggle
• Webhook callback for async completion notifications
• Custom S3 storage for output files

Integrations: Clients and Platforms

Last verified: 2026-02-09

Table of Contents

• AI Coding Assistants
• AI Platforms
• Browser Extensions

AI Coding Assistants

Cursor

1. Open Settings -> Models 2. Uncheck default models 3. Add the model selected by the user or application: <MODEL_NAME> 4. Set OpenAI Base URL: https://api.novita.ai/openai 5. Enter your Novita API Key 6. Click Verify

Continue (VS Code / JetBrains)

Edit ~/.continue/config.json:

{
  "models": [
    {
      "title": "Novita",
      "provider": "openai",
      "model": "<MODEL_NAME>",
      "apiBase": "https://api.novita.ai/openai",
      "apiKey": "<YOUR_API_KEY>"
    }
  ]
}

Claude Code

export OPENAI_API_BASE=https://api.novita.ai/openai
export OPENAI_API_KEY=<YOUR_API_KEY>

CodeCompanion (Neovim)

require("codecompanion").setup({
  adapters = {
    novita = function()
      return require("codecompanion.adapters").extend("openai", {
        url = "https://api.novita.ai/openai/v1/chat/completions",
        env = { api_key = "NOVITA_API_KEY" },
        schema = { model = { default = os.getenv("NOVITA_MODEL") or "<MODEL_NAME>" } },
      })
    end,
  },
})

AI Platforms

Dify

1. Go to Settings -> Model Providers 2. Find Novita AI in the list 3. Paste your API key 4. Click Save

LangFlow

1. Add ChatOpenAI component 2. Set OpenAI API Base: https://api.novita.ai/openai 3. Set OpenAI API Key: your Novita key 4. Set Model Name: <MODEL_NAME>

AnythingLLM

1. Go to Settings -> LLM Preference 2. Select Novita AI or Generic OpenAI 3. Enter API key and base URL 4. Choose model

Browser Extensions

LobeChat

1. Go to Settings -> Language Models 2. Enable Novita AI provider 3. Enter API key 4. Select model

ChatBox

1. Open Settings 2. Add new AI provider: OpenAI API Compatible 3. API Host: https://api.novita.ai 4. API Key: your Novita key 5. Model: <MODEL_NAME>

Page Assist

1. Click extension icon -> Settings 2. Select Novita AI or Custom OpenAI 3. Enter API key and base URL

Integrations: Frameworks

Last verified: 2026-02-09

Table of Contents

• LangChain (Python)
• LlamaIndex
• OpenAI Agents SDK

LangChain (Python)

import os
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    base_url="https://api.novita.ai/openai",
    api_key=os.environ["NOVITA_API_KEY"],
    model=os.environ["NOVITA_MODEL"],
)

response = llm.invoke("Hello!")
print(response.content)

For other SDKs/languages, generate equivalent code from these Python baselines and the OpenAI-compatible base URL.

LlamaIndex

import os
from llama_index.llms.openai_like import OpenAILike

llm = OpenAILike(
    api_base="https://api.novita.ai/openai",
    api_key=os.environ["NOVITA_API_KEY"],
    model=os.environ["NOVITA_MODEL"],
)

OpenAI Agents SDK

import os
from agents import Agent
from openai import OpenAI

client = OpenAI(
    base_url="https://api.novita.ai/openai",
    api_key=os.environ["NOVITA_API_KEY"],
)

agent = Agent(
    name="Assistant",
    model=os.environ["NOVITA_MODEL"],
)

Integrations: Observability, Agents, and Training

Last verified: 2026-02-09

Table of Contents

• Observability and Proxy
• AI Agents
• Model Training

Observability and Proxy

LiteLLM (Proxy)

import os
import litellm

response = litellm.completion(
    model=f"openai/{os.environ['NOVITA_MODEL']}",
    api_base="https://api.novita.ai/openai",
    api_key=os.environ["NOVITA_API_KEY"],
    messages=[{"role": "user", "content": "Hello!"}]
)

Helicone (Logging)

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.novita.ai/openai",
    api_key=os.environ["NOVITA_API_KEY"],
    default_headers={
        "Helicone-Auth": "Bearer <HELICONE_KEY>",
    }
)

Langfuse (Tracing)

Langfuse traces OpenAI-compatible calls automatically once configured:

import os
from langfuse.openai import openai

openai.api_base = "https://api.novita.ai/openai"
openai.api_key = os.environ["NOVITA_API_KEY"]

Portkey (Gateway)

import os
from portkey_ai import Portkey

client = Portkey(
    base_url="https://api.novita.ai/openai",
    api_key=os.environ["NOVITA_API_KEY"],
    virtual_key="novita-xxx"
)

AI Agents

Browser Use

import asyncio
import os
from browser_use import Agent
from langchain_openai import ChatOpenAI

async def main():
    llm = ChatOpenAI(
        base_url="https://api.novita.ai/openai",
        api_key=os.environ["NOVITA_API_KEY"],
        model=os.environ["NOVITA_MODEL"],
    )

    agent = Agent(task="Search for...", llm=llm)
    await agent.run()

asyncio.run(main())

Skyvern

Set in environment:

LLM_API_BASE=https://api.novita.ai/openai
LLM_API_KEY=<YOUR_API_KEY>
MODEL_NAME=<MODEL_NAME>

Model Training

Axolotl

Use this in your Axolotl config file:

base_model: novita/model-name
api_url: https://api.novita.ai/openai

Kohya SS GUI

Use Novita for inference endpoints in training pipelines.

Integrations Guide

Use this file as the integrations router. Open exactly one category file based on user intent.

Last verified: 2026-02-09

Universal Setup (All Integrations)

• Base URL: https://api.novita.ai/openai
• API Key: Get from https://novita.ai/settings/key-management
• Model: Use the model selected by the user or application (<MODEL_NAME>)

Category Map

• Frameworks and SDKs: integrations-frameworks.md
• Clients and platforms: integrations-clients.md
• Observability, agents, and training: integrations-observability-agents.md

Tool-to-Category Map

• LangChain, LlamaIndex, OpenAI Agents SDK -> integrations-frameworks.md
• Cursor, Continue, Claude Code, Dify, LobeChat -> integrations-clients.md
• LiteLLM, Portkey, Langfuse, Browser Use, Skyvern, Axolotl -> integrations-observability-agents.md

Full Integration Docs

For detailed guides: https://novita.ai/docs/guides/langchain

Novita AI LLM API Reference

Security: All inputs — text, images, video, audio — should come from trusted sources only. Never embed unverified content directly into system prompts.

OpenAI-compatible API. Base: https://api.novita.ai/openai/v1

Table of Contents

• Chat Completions
• Completions
• Embeddings
• Rerank
• Models
• Batch Processing

Chat Completions

POST /openai/v1/chat/completions

Required Parameters

Optional Parameters

Function Calling

{
  "tools": [{
    "type": "function",
    "function": {
      "name": "get_weather",
      "description": "Get weather for a location",
      "parameters": {
        "type": "object",
        "properties": {
          "location": {"type": "string"}
        },
        "required": ["location"]
      }
    }
  }]
}

Structured Outputs

{
  "response_format": {
    "type": "json_schema",
    "json_schema": {
      "name": "response",
      "schema": {
        "type": "object",
        "properties": {
          "answer": {"type": "string"},
          "confidence": {"type": "number"}
        }
      },
      "strict": true
    }
  }
}

Also supports "type": "json_object" for freeform JSON.

Reasoning Output

For models that expose reasoning content:

• separate_reasoning: true — returns reasoning in choices[].message.reasoning_content
• enable_thinking: true/false — toggle thinking mode where supported

Multimodal (Vision)

Content can be an array of parts with text, image, video, or audio. For multimodal inputs, the message content is an array instead of a string:

• Text part: type "text" with a "text" field
• Image part: include the image data or a reference to a trusted local image
• Video part: include the video data or a reference to a trusted local video
• Audio part: type "input_audio" with the audio data

All media references in multimodal messages should come from trusted local sources only.

Response Format

{
  "id": "chatcmpl-xxx",
  "object": "chat.completion",
  "created": 1234567890,
  "model": "<MODEL_NAME>",
  "choices": [{
    "index": 0,
    "finish_reason": "stop",
    "message": {"role": "assistant", "content": "Hello!"}
  }],
  "usage": {"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15}
}

Streaming: SSE format, each line data: <json>, terminated by data: [DONE].

Completions

POST /openai/v1/completions

Same parameters as chat but uses prompt (string) instead of messages.

Embeddings

POST /openai/v1/embeddings

Returns data[].embedding (float array).

Rerank

POST /openai/v1/rerank

Returns results[].{index, relevance_score}.

Models

• GET /openai/v1/models — List all models
• GET /openai/v1/models/{model_id} — Get model details

Batch Processing

Upload File

POST /openai/v1/files (multipart form)

• file: JSONL file
• purpose: "batch"

JSONL Format

Each line: {"custom_id": "req-1", "method": "POST", "url": "/v1/chat/completions", "body": {<chat params>}}

Create Batch

POST /openai/v1/batches

{"input_file_id": "file-xxx", "endpoint": "/v1/chat/completions", "completion_window": "48h"}

Other Batch Endpoints

• GET /openai/v1/batches — List batches
• GET /openai/v1/batches/{batch_id} — Get batch status
• POST /openai/v1/batches/{batch_id}/cancel — Cancel batch

File Management

• GET /openai/v1/files — List files
• GET /openai/v1/files/{file_id} — Get file info
• GET /openai/v1/files/{file_id}/content — Download file content
• DELETE /openai/v1/files/{file_id} — Delete file

LLM API Guide

Novita AI provides OpenAI-compatible APIs for a continuously updated model catalog.

Last verified: 2026-02-09

Table of Contents

• Quick Setup
• Basic Chat Completion
• Key Parameters
• Function Calling (Tool Use)
• Vision (Image Input)
• Structured Outputs (JSON Mode)
• Batch API
• Advanced Features
• API Reference

Quick Setup

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.novita.ai/openai",
    api_key=os.environ["NOVITA_API_KEY"],
)

Basic Chat Completion

response = client.chat.completions.create(
    model=os.environ["NOVITA_MODEL"],
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello!"}
    ],
    max_tokens=512,
    stream=True,  # Recommended for long responses
)

for chunk in response:
    print(chunk.choices[0].delta.content or "", end="")

Key Parameters

Model Selection

• Browse models: https://novita.ai/models
• Query via API: GET https://api.novita.ai/openai/v1/models
• Format: provider/model-name
• Do not assume a default model; use the user's selected model or NOVITA_MODEL.
• Fetch latest models:

curl https://api.novita.ai/openai/v1/models \
  -H "Authorization: Bearer $NOVITA_API_KEY"

Output Control

Repetition Control

---

Function Calling (Tool Use)

Enable LLMs to call external functions/APIs.

Model Support

Function-calling support varies by model. Verify current support in the live model catalog before selecting a model.

Example

Define tools, call the model with tools, then read the returned tool call.

import json

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get weather for a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "City and state, e.g. San Francisco, CA"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

response = client.chat.completions.create(
    model=os.environ["NOVITA_MODEL"],
    messages=[{"role": "user", "content": "What's the weather in Tokyo?"}],
    tools=tools,
)

tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.function.name)       # "get_weather"
print(tool_call.function.arguments)  # '{"location": "Tokyo, Japan"}'

---

Vision (Image Input)

Process images with Vision-Language Models.

Model Support

Vision support varies by model. Verify current support in the live model catalog before selecting a model.

Image via URL

response = client.chat.completions.create(
    model=os.environ["NOVITA_MODEL"],
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://example.com/image.jpg",
                        "detail": "high"  # high, low, or auto
                    }
                },
                {"type": "text", "text": "Describe this image."}
            ]
        }
    ],
)

Image via Base64

import base64

with open("image.jpg", "rb") as f:
    base64_image = base64.b64encode(f.read()).decode("utf-8")

response = client.chat.completions.create(
    model=os.environ["NOVITA_MODEL"],
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/jpeg;base64,{base64_image}",
                        "detail": "high"
                    }
                },
                {"type": "text", "text": "What text is in this image?"}
            ]
        }
    ],
)

---

Structured Outputs (JSON Mode)

Force LLM to output valid JSON matching your schema.

Example

response = client.chat.completions.create(
    model=os.environ["NOVITA_MODEL"],
    messages=[
        {"role": "system", "content": "Extract expense info as JSON."},
        {"role": "user", "content": "I spent $50 on lunch and $30 on coffee today."}
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "expenses",
            "schema": {
                "type": "object",
                "properties": {
                    "items": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "description": {"type": "string"},
                                "amount": {"type": "number"},
                                "category": {"type": "string"}
                            },
                            "required": ["description", "amount"]
                        }
                    }
                },
                "required": ["items"]
            }
        }
    }
)

---

Batch API

Process large volumes of requests asynchronously with discounted batch pricing (see live pricing/docs for current terms).

Workflow

1. Upload JSONL file with requests 2. Create batch job 3. Poll for completion 4. Download results

with open("requests.jsonl", "rb") as f:
    file = client.files.create(file=f, purpose="batch")

batch = client.batches.create(
    input_file_id=file.id,
    endpoint="/v1/chat/completions",
    completion_window="24h"
)

status = client.batches.retrieve(batch.id)
print(status.status)  # "completed"

results = client.files.content(status.output_file_id)

---

Advanced Features

Prompt Caching

Automatically caches repeated prompt prefixes for faster responses and lower costs.

Reasoning Output

Some models expose reasoning content:

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

Streaming

Always use streaming for long outputs to avoid timeouts:

stream = client.chat.completions.create(
    model=os.environ["NOVITA_MODEL"],
    messages=[...],
    stream=True,
)
for chunk in stream:
    print(chunk.choices[0].delta.content or "", end="")

---

API Reference

• Endpoint: POST https://api.novita.ai/openai/v1/chat/completions
• Full API docs: https://novita.ai/docs/api-reference/model-apis-llm-create-chat-completion
• Rate limits: Vary by account tier and model; verify current limits in docs/console

Novita AI Quick Start

Get started with Novita AI in 5 minutes.

Last verified: 2026-02-09

1. Get Your API Key

1. Log in at https://novita.ai (Google/GitHub/Email) 2. Go to Key Management 3. Create a new API key

2. Make Your First API Call

Novita AI is OpenAI SDK compatible. Just change the base URL.

Python (OpenAI SDK)

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.novita.ai/openai",
    api_key=os.environ["NOVITA_API_KEY"],
)

response = client.chat.completions.create(
    model=os.environ["NOVITA_MODEL"],
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello!"}
    ],
    max_tokens=512,
)
print(response.choices[0].message.content)

cURL

curl https://api.novita.ai/openai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $NOVITA_API_KEY" \
  -d '{
    "model": "<MODEL_NAME>",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "Hello!"}
    ],
    "max_tokens": 512
  }'

For other SDKs/languages, generate equivalent code from this Python baseline and the OpenAI-compatible base URL.

3. Explore Models

• Browse models: https://novita.ai/models
• Query via API: GET https://api.novita.ai/openai/v1/models

Model Selection

Do not assume a default model. Use the model selected by the user or application. If no model is selected, browse https://novita.ai/models or query the model API and choose based on the task requirements.

4. Add Credits

New users get free credits. To add more: 1. Visit Billing 2. Add payment method 3. Optionally enable Auto Top-up

Next Steps

• LLM API Guide - Advanced features like function calling, vision
• GPU Guide - Dedicated GPU instances
• Integrations - Use with LangChain, Cursor, etc.

Novita AI Video API Reference

All video endpoints are async — they return task_id. Poll with GET /v3/async/task-result?task_id=X.

Table of Contents

• Unified Video API
• Model Discovery
• Legacy SD Video Endpoints

Unified Video API

POST https://api.novita.ai/v3/video/create — Async

Use this endpoint for unified video task creation. Each model has its own parameter schema.

Common Parameters

Model-Specific Parameters

Model parameters are dynamic. Fetch the configuration:

curl https://api.novita.ai/v3/admin/video-unify-api/config \
  -H "Authorization: Bearer $NOVITA_API_KEY"

Returns each model's json_schema with supported parameters (prompt, image, resolution, duration, etc.).

Example: Text-to-Video

curl -X POST https://api.novita.ai/v3/video/create \
  -H "Authorization: Bearer $NOVITA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "<VIDEO_MODEL_NAME>",
    "prompt": "A cat playing piano in a jazz bar",
    "resolution": "720p",
    "duration": 5
  }'

Example: Image-to-Video

For image-to-video, include the encoded image data from a local file in the image field along with a text prompt, model name, and duration.

Model Discovery

Do not use a static video model list as a recommendation. Fetch the unified video API configuration and select the model requested by the user or required by the application.

curl https://api.novita.ai/v3/admin/video-unify-api/config \
  -H "Authorization: Bearer $NOVITA_API_KEY"

Use the returned json_schema to build valid request bodies for the selected model.

Legacy SD Video Endpoints

Text-to-Video (SD)

POST https://api.novita.ai/v3/async/txt2video

Image-to-Video (SVD)

POST https://api.novita.ai/v3/async/img2video

Hunyuan Video Fast

POST https://api.novita.ai/v3/async/hunyuan-video-fast

Task Result

Poll: GET /v3/async/task-result?task_id=X

Success response includes a videos array, where each entry contains a time-limited download link, its TTL in seconds, and the video format (mp4).