Doubao Seed 2.1 API on Tokuse: Pro vs Lite vs Turbo, Pricing, and Setup

Tokuse now routes three models from ByteDance's Doubao Seed 2.1 family through one OpenAI-compatible endpoint. That gives teams a new set of price points between the cheapest DeepSeek workloads and the most expensive frontier models — and a real choice between three tiers that share an API shape but not a cost profile.

This guide compares doubao-seed-2-1-pro-260915, doubao-seed-2-1-lite-260915, and doubao-seed-2-1-turbo-260628 using the live Tokuse model catalog on November 16, 2026. It covers what each tier is for, what a production workload actually costs, how to call the models with the OpenAI or Anthropic SDK, and how to choose between Doubao and DeepSeek without rewriting application code.

Prices change. Always confirm the current rate on the Tokuse pricing page before committing a budget.

The short version

Two numbers stand out:

• Lite is the cost floor for balanced workloads. It costs roughly 60% less than DeepSeek Flash on both input and output at current Tokuse rates.
• Turbo is not a cheaper Lite. Its input price is the lowest of the three, but its output price is about 5.9 times Lite's. Turbo wins only when a workload sends a lot of input and returns very few output tokens.

Pro is the capability tier. It costs more than both, and it is the model to test when Lite fails a quality bar rather than the model to use for every request.

What each Doubao Seed 2.1 tier is for

The three models are positioned by workload shape, not by a single benchmark score.

Doubao Seed 2.1 Pro is the top tier in this family. Route planning, multi-step tool use, long documents, and answers that need careful instruction following belong here. The output price is the highest of the three, so it makes sense for jobs where a wrong answer is more expensive than the tokens.

Doubao Seed 2.1 Lite is the balanced tier. It is the right default for customer support, summarization, structured extraction, tagging, classification, and routine agent steps. At $0.1096 input and $0.3699 output per million tokens, it can absorb high request volume without the bill scaling as fast as the output does.

Doubao Seed 2.1 Turbo is optimized for input-heavy, output-light work. Think retrieval pipelines that read long contexts and return a label, a JSON object, or a short routing decision. Its $0.0876 input price is the lowest in the family, but a long generated answer quickly becomes expensive because output is billed at $2.1900 per million tokens.

The practical rule: start on Lite, test quality on your own prompts, escalate the failing slice to Pro, and use Turbo only when output length is genuinely bounded.

What a real workload costs

Token prices are easy to misread. A workload that looks cheap per token can still produce a large bill when output dominates.

Here is the same 100 million input tokens and 20 million output tokens priced across the family and across two DeepSeek alternatives on Tokuse:

Lite is about 63% cheaper than DeepSeek Flash for this mix. Turbo is slightly more expensive than DeepSeek Flash because its output is 2.19 times the price. Pro sits close to DeepSeek V4 Pro, which is what a capability-tier model should look like.

Change the workload shape and the ranking changes:

For output-heavy work such as long reports, code generation, or conversational answers, Lite remains the cheapest option in this group. Turbo is only competitive when output is a tiny fraction of input.

The cache caveat

DeepSeek publishes a cache-hit rate, and Tokuse exposes it in the model catalog. At the current deepseek-flash rate, a cache hit costs about $0.006 per million input tokens — far below the $0.274 cache-miss rate.

Doubao Seed 2.1 pricing in the Tokuse catalog does not assume a cache discount. If your workload repeats the same long system prompt or agent context, model the cache-hit ratio before assuming Lite is always cheaper. For a small-output workload with 95% cache hits, DeepSeek Flash can beat Lite on total cost even though its list input price is higher. For output-heavy work, the cheaper output rate on Lite still dominates.

The honest answer is workload-specific, which is why the cost calculator and Tokuse usage logs matter more than a single headline price.

Call Doubao Seed 2.1 with the OpenAI SDK

All three models accept an OpenAI-compatible chat completions request at https://tokuse.com/v1. Keep your existing SDK and change the base URL and model ID.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["TOKUSE_API_KEY"],
    base_url="https://tokuse.com/v1",
)

response = client.chat.completions.create(
    model="doubao-seed-2-1-lite-260915",
    messages=[
        {"role": "system", "content": "Extract the customer intent as JSON."},
        {"role": "user", "content": "I was charged twice and need a refund."},
    ],
)

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

The same pattern works in Node.js:

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.TOKUSE_API_KEY,
  baseURL: "https://tokuse.com/v1",
});

const response = await client.chat.completions.create({
  model: "doubao-seed-2-1-pro-260915",
  messages: [{ role: "user", content: "Summarize this contract." }],
});

Or with a direct HTTP request:

curl https://tokuse.com/v1/chat/completions \
  -H "Authorization: Bearer $TOKUSE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "doubao-seed-2-1-turbo-260628",
    "messages": [{"role": "user", "content": "Classify: refund request"}],
    "temperature": 0
  }'

Use the Anthropic Messages protocol instead

Doubao Seed 2.1 models on Tokuse also support the Anthropic Messages shape. Use https://tokuse.com as the base URL and keep the /v1/messages path handled by the SDK:

import os
import anthropic

client = anthropic.Anthropic(
    api_key=os.environ["TOKUSE_API_KEY"],
    base_url="https://tokuse.com",
)

message = client.messages.create(
    model="doubao-seed-2-1-pro-260915",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Plan a three-step migration."}],
)

print(message.content[0].text)

If you already use an Anthropic-compatible client for Claude workloads, this lets you test Doubao without adding a second SDK. The full protocol reference is in the Anthropic Messages guide.

Streaming, timeouts, and common errors

Streaming works the same way as other OpenAI-compatible models:

stream = client.chat.completions.create(
    model="doubao-seed-2-1-lite-260915",
    messages=[{"role": "user", "content": "Write a short product update."}],
    stream=True,
)

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

A few failures are worth handling explicitly:

• 401 usually means a missing key, a key with trailing whitespace, or a request sent to the wrong base URL.
• 404 usually means the model ID or path is wrong. Doubao IDs include date suffixes such as 260915; copy the exact ID from the Tokuse catalog instead of guessing.
• 429 means rate or quota limits. Use bounded exponential backoff with jitter, and do not retry the same request forever.
• Timeouts can happen on long generations. Set client timeouts above your expected p95 latency, and treat a timeout as unknown state rather than as a failed generation.

The Chat Completions reference covers the request shape in more detail.

How to choose a tier in production

A simple routing policy is enough for most teams:

1. Default to Lite. It is the lowest-cost option for balanced and output-heavy traffic.
2. Escalate to Pro by task, not by request volume. Run an evaluation set of 20–50 real prompts. If Lite misses the quality bar on a specific intent, route only that intent to Pro.
3. Use Turbo when output is strictly capped. Classification, extraction, routing, and retrieval-augmented lookups with one-line answers are good fits. Long chat answers are not.
4. Compare against DeepSeek when context repeats. If most input tokens hit a cache, model the effective input cost before switching.
5. Log usage by model and intent. Tokuse usage logs make it possible to see which tier actually earns its cost, rather than guessing from a list price.

This is also the safest way to evaluate response quality. Run the same prompt set through Lite, Pro, and Turbo, keep the outputs, and score them against your own criteria. No published benchmark replaces that step.

Production checklist

Before moving traffic, confirm:

• The model ID is available to your Tokuse group. Doubao models are group-specific; the catalog shows which group exposes them.
• The ID is pinned in configuration, not discovered at runtime from a changing alias.
• The client timeout is longer than the expected generation time.
• Retries are bounded and use jitter.
• Usage is logged by model, intent, and cost center.
• Output parsing handles JSON fences and partial streaming chunks.
• A fallback model is configured for 429 and 5xx responses.

FAQ

Is Doubao Seed 2.1 OpenAI-compatible on Tokuse?
Yes. Use https://tokuse.com/v1 with the OpenAI Chat Completions shape and the exact Doubao model ID.

Can I keep the OpenAI or Anthropic SDK?
Yes. Change the base URL and model ID; the request shape stays the same. Doubao models on Tokuse support both protocols.

Which tier is cheapest?
For balanced and output-heavy workloads, Lite is the lowest-cost option in the current catalog. Turbo is cheaper only when input is large and output is very short. See the pricing page for live rates.

How do I switch between Doubao and DeepSeek?
They share the same gateway. Change the model field; no endpoint or SDK change is required.

Where can I estimate a workload first?
Use the free cost calculator and then verify the exact model ID and rate on Tokuse pricing.

Can I use Doubao with Continue, Cline, Cursor, or LangChain?
Yes. Any client that accepts an OpenAI-compatible base URL can point at Tokuse. The integration guides cover the common developer tools.

Try the three tiers on your own prompts

The useful comparison is not a list price. It is the quality and cost your application gets on the prompts it actually sends.

Create a Tokuse account, test Lite as the default, and escalate only the intents that need Pro. Start here: tokuse.com/register.

For related cost work, read the DeepSeek pricing guide, compare DeepSeek Flash and Pro, or check the API documentation.