DeepSeek, Qwen, GLM. One API.

Plus Gemma and Nemotron. Call them with the OpenAI SDK and pay for the tokens you use.

DeepSeek, Qwen, GLM, Gemma and Nemotron models, served through one OpenAI-compatible API at https://models.jarvislabs.net/v1.

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.

  • DeepSeek V4 FlashFP8

    DeepSeek

    • Reasoning
    • Tool calling
    • JSON output
    Context
    1M
    Input
    $0.13
    Cached
    $0.03
    Output
    $0.26
    Try
  • DeepSeek V4.1 FlashFP8

    DeepSeek

    • Reasoning
    • Image input
    • Tool calling
    • JSON output
    Context
    1M
    Input
    $0.07
    Cached
    $0.003
    Output
    $0.49
    Try
  • Gemma 4 26B A4B ITBF16

    Google

    • Reasoning
    • Image input
    • Tool calling
    • JSON output
    Context
    256K
    Input
    $0.11
    Cached
    $0.05
    Output
    $0.37
    Try
  • Gemma 4 31B ITBF16

    Google

    • Reasoning
    • Image input
    • Tool calling
    • JSON output
    Context
    256K
    Input
    $0.14
    Cached
    $0.05
    Output
    $0.40
    Try
  • GLM-5.3FP8

    Z.ai

    • Reasoning
    • Tool calling
    • JSON output
    Context
    230K
    Input
    $1.21
    Cached
    $0.22
    Output
    $3.86
    Try
  • GLM-5.3 FlashFP8

    Z.ai

    • Reasoning
    • Image input
    • Tool calling
    • JSON output
    Context
    1M
    Input
    $0.14
    Cached
    $0.03
    Output
    $0.45
    Try
  • Nemotron 3.5 Super VL 120B A12B NVFP4

    NVIDIA

    • Reasoning
    • Image input
    • Tool calling
    • JSON output
    Context
    1M
    Input
    $0.15
    Cached
    $0.02
    Output
    $0.50
    Try
  • Qwen 3.8 27B FP8

    Alibaba

    • Reasoning
    • Image input
    • Tool calling
    • JSON output
    Context
    256K
    Input
    $0.30
    Cached
    $0.08
    Output
    $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 catalog

What 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.

  1. Try a prompt

    Pick a model in the playground and adjust its settings. Export the request as Python, TypeScript or cURL.

    Open the playground
  2. Create an API key

    Keys live in your account settings. Keep them on your server, out of browser code.

    Manage API keys
  3. 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

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.