DeepSeek, Qwen, GLM. One API.
Plus Gemma and Nemotron. Call them with the OpenAI SDK and pay for the tokens you use.
DeepSeek
QwenAlibaba
GLMZ.ai
GemmaGoogle
NemotronNVIDIA
One API
models.jarvislabs.net/v1
- OpenAI-compatible
- Streaming responses
- Billed per token
Models and pricing
Every model, priced per token.
Input, cached-input and output rates for each model, with its context window and capabilities. Copy a model ID, or try the model in the playground.
USD per 1 million tokens. Context is the window we serve.
- Context
- 1M
- Input
- $0.13
- Cached
- $0.03
- Output
- $0.26
- Context
- 1M
- Input
- $0.07
- Cached
- $0.003
- Output
- $0.49
- Context
- 256K
- Input
- $0.11
- Cached
- $0.05
- Output
- $0.37
- Context
- 256K
- Input
- $0.14
- Cached
- $0.05
- Output
- $0.40
- Context
- 230K
- Input
- $1.21
- Cached
- $0.22
- Output
- $3.86
- Context
- 1M
- Input
- $0.14
- Cached
- $0.03
- Output
- $0.45
Nemotron 3.5 Super VL 120B A12B NVFP4
NVIDIA·
- ReasoningReasoning
- VisionImage input
- ToolsTool calling
- JSONJSON output
- Context
- 1M
- Input
- $0.15
- Cached
- $0.02
- Output
- $0.50
- Context
- 256K
- Input
- $0.30
- Cached
- $0.08
- Output
- $2.35
| Model | Context | Input | Cached input | Output | Playground |
|---|---|---|---|---|---|
| 1M | $0.13 | $0.03 | $0.26 | Try | |
| 1M | $0.07 | $0.003 | $0.49 | Try | |
| 256K | $0.11 | $0.05 | $0.37 | Try | |
| 256K | $0.14 | $0.05 | $0.40 | Try | |
| 230K | $1.21 | $0.22 | $3.86 | Try | |
| 1M | $0.14 | $0.03 | $0.45 | Try | |
Nemotron 3.5 Super VL 120B A12B NVFP4 NVIDIA·
| 1M | $0.15 | $0.02 | $0.50 | Try |
| 256K | $0.30 | $0.08 | $2.35 | Try |
Input is the context you send. Output is what the model generates, including reasoning tokens. Cached input applies when the start of a prompt matches one the model has already processed. Sign in for current availability and prices in your billing currency.
Open the model catalogWhat the API supports
The Chat Completions features you already use.
Each model’s row in the table shows which of these it supports.
Streaming
Set stream to true to receive tokens as server-sent events. Add stream_options to get token usage in the final chunk.
Tool calling
Models marked Tools can call functions you define. Your app runs the tool and sends back the result.
JSON output
Models marked JSON can follow a JSON Schema you provide, so replies have the shape your code expects.
Reasoning controls
Models marked Reasoning think before they answer. Turn thinking on or off per request, and set the effort where a model offers levels.
Image input
Models marked Vision accept images alongside text. Some also accept video.
Long context
Context windows up to 1M tokens. Each row in the table lists the window we serve.
Data and billing
Your prompts stay yours.
We serve each request on our own GPUs and keep no copy of it, and usage bills per token from the credit balance you already have.
Prompts aren’t stored
We don’t store your prompts or completions, and we don’t train on them.
Cached input is automatic
When the start of a prompt matches one the model has already processed, those input tokens bill at the cached-input rate. There is no cache-write fee and nothing to configure.
One credit balance
Token usage draws from the same Jarvislabs credit balance as your GPU instances. Add credits once and use both.
Get started
From first prompt to production.
Try a model in the playground, create an API key, then point your OpenAI client at Jarvislabs.
- 01
Try a prompt
Pick a model in the playground and adjust its settings. Export the request as Python, TypeScript or cURL.
Open the playground - 02
Create an API key
Keys live in your account settings. Keep them on your server, out of browser code.
Manage API keys - 03
Change the base URL
Point the OpenAI SDK at
https://models.jarvislabs.net/v1, set your key and use a model ID from the table. The example shows the whole request.
$ pip install openai
import os
from openai import OpenAI
client = OpenAI(
base_url="https://models.jarvislabs.net/v1",
api_key=os.environ["JARVISLABS_API_KEY"],
)
response = client.chat.completions.create(
model="glm-5.3",
messages=[
{"role": "user", "content": "Say hello in one sentence."},
],
)
print(response.choices[0].message.content)Set JARVISLABS_API_KEY in your environment before running.
Inference on Jarvislabs
Pay per token, or run your own deployment.
Start on Token Factory, then move to a deployment of your own when you need dedicated capacity or a custom model.
How the three ways to serve a model differ.
- What you get
- Token Factory
- A hosted model behind a shared API
- Managed Endpoints
- Your own endpoint for a model from our deployment catalog
- Serverless
- Your own endpoint for any open model
- You pay for
- Token Factory
- Input, cached-input and output tokens
- Managed Endpoints
- GPU worker runtime, per minute
- Serverless
- Worker runtime, per minute
- Serving stack
- Token Factory
- Run by Jarvislabs
- Managed Endpoints
- Maintained by Jarvislabs
- Serverless
- You configure vLLM, SGLang or Ollama
- Scaling
- Token Factory
- Handled by Jarvislabs
- Managed Endpoints
- You set the workers
- Serverless
- Autoscaling worker pool you configure
- When idle
- Token Factory
- No charge
- Managed Endpoints
- Warm workers keep billing; scale to zero to stop
- Serverless
- Storage only, once scaled to zero
| Token Factory | Managed Endpoints | Serverless | |
|---|---|---|---|
| What you get | A hosted model behind a shared API | Your own endpoint for a model from our deployment catalog | Your own endpoint for any open model |
| You pay for | Input, cached-input and output tokens | GPU worker runtime, per minute | Worker runtime, per minute |
| Serving stack | Run by Jarvislabs | Maintained by Jarvislabs | You configure vLLM, SGLang or Ollama |
| Scaling | Handled by Jarvislabs | You set the workers | Autoscaling worker pool you configure |
| When idle | No charge | Warm workers keep billing; scale to zero to stop | Storage only, once scaled to zero |
Before you start
Common questions.
Practical details for choosing and using this product.
Do I need to rent a GPU first?
No. Token Factory models are already running. Create an API key, choose a model and send a request. You pay for tokens, not GPU time.
Which models can I use?
Models from the DeepSeek, Gemma, GLM, Nemotron and Qwen families. The table on this page lists each one with its context window, capabilities and token rates; the dashboard shows current availability.
Can I use the OpenAI SDK?
Yes, for Chat Completions. Set the base URL to https://models.jarvislabs.net/v1, use your Jarvislabs API key and pick a model ID from the table. The Responses API is not supported.
How is API usage charged?
Per million input, cached-input and output tokens, at the rates listed for the model you call. Reasoning tokens count as output. Usage draws from your Jarvislabs credit balance, the same one your GPU instances use, so you need credits before you send a request.
Do you store my prompts or train on them?
No. We don’t store your prompts or completions, and we don’t train on them.
Where are the models hosted?
On Jarvislabs GPUs in our India region.
How does cached-input pricing work?
When the start of your prompt matches one the model has already processed, those input tokens bill at the lower cached-input rate. It happens automatically, with no cache-write fee. The usage in each response shows how many input tokens were cached.
How is this different from Managed Endpoints and Serverless?
With Token Factory, you call a model we already host and pay per token. With Managed Endpoints or Serverless, you get your own deployment and pay for worker runtime, whether or not it is busy.
Pick a model and send your first request.
Try a prompt in the playground, then call the same model from your code.