Dola Seed 2.0 Pro is the flagship of ByteDance's Dola Seed 2.0 family on BytePlus ModelArk, described officially as a general-purpose agentic model built for the Agent era.
- Input
- text image video $0.5/M
- Output
- text $3/M
- Cache read
- $0.1/M
- Context
- 262K
- vs GPT-4o
- ~90% cheaper
Price in context
Where the price sits among 60 comparable models
The bar shows how this model’s price compares with every other model of the same kind on Synthorai. The cheapest and the most expensive are named at each end. These are base rates; batch, region and cache-write discounts are on the pricing page.
Specs & limits
Tokens
| Context window (vendor spec) | 256,000 |
|---|---|
| Max output (vendor spec) | 131,072 |
Prompt caching
| How it caches | automatic + explicit |
|---|---|
| Min prefix | 1,024 |
Thinking
| Vendor control | thinking.type + reasoning_effort |
|---|---|
| Accepted values | thinking.type enabled · disabled (no auto); reasoning_effort minimal · low · medium · high |
| Default | enabled, with reasoning_effort medium and thinking summary on applied when the request sets nothing |
| Can be turned off | Yes |
| Thinking behaviour | Thinking summary is on by default, so reasoning_content carries a summary alongside encrypted_content rather than the raw trace; on tool-calling turns encrypted_content must be passed back or inference quality degrades. |
| Parameter | reasoning_effort |
| Values | minimal · low · medium · high the gateway's parameter surface - the vendor mapping above applies |
Model
| Modalities | text + image + video → text |
|---|
General-purpose agentic flagship with deep reasoning, visual grounding and tool calling in a 256K context.
One prompt, measured through the gateway
Dola Seed 2.0 Pro passed · 3 sentences
Reasoning-enabled LLMs do not generate final answers in one pass: they run hundreds of unshown internal trial, cross-check, and correction steps for every user request, and every one of these hidden steps consumes billable GPU time just like the visible output text. Unlike our prior standard chat workload which only processed exactly what users typed, reasoning mode automatically executes these validation loops by default, with no visible indicator to end users that extra compute is being consumed. This 2x increase is not a billing error or rogue usage spike: industry benchmarks consistently put reasoning workloads at 1.7-2.6x the compute cost of equivalent standard LLM requests, and this pricing dynamic is almost never clearly disclosed on vendor rate cards.
out 563 tok (+416 thinking) latency 9.4 s
Instruction following (exactly three sentences - countable), audience shaping (CFO register), and the hidden-thinking billing gap the token meters below expose.
Dola Seed 2.0 Pro passed · 8/8 cases
### Corrected Implementation ```python def longest_run(xs): if not xs: return 0 best = 1 cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 best = max(best, cur) else: cur = 1 return best ``` --- ### Bug Explanation The original code has three critical linked flaws: 1. It initialized run counters `best` and `cur` to `0` instead of `1`, failing to account for the fact that *every individual element is already a valid run of length 1* -- this causes single-element inputs to incorrectly return `0`. 2. `cur` only counted how many extra matching elements followed the start of a run, so it always tracked one less than the actual run length, and it reset to `0` (instead of `1`) when a new run began, preserving this off-by-one error for all runs. 3. […]
out 1278 tok (+951 thinking) latency 16.7 s
Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.
Dola Seed 2.0 Pro passed · 5/5 fields, guidance null
{ "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": 11, "guidance": null }
out 506 tok (+452 thinking) latency 8.6 s
Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.
Dola Seed 2.0 Pro passed · 123 words, 0 banned, 1 question
Today we’re rolling out cross-provider prompt caching for our API gateway. For engineering teams routing LLM requests across OpenAI, Anthropic, Mistral and open source models, this feature stores identical prompt payloads at the gateway layer, rather than relying on per-provider cache implementations limited to single endpoints. How much time and compute could your team save by avoiding redundant token processing for repeated system prompts, context windows, or common user queries? Cache hits return responses in under 10ms, with configurable TTL, granular purge controls, and per-application cache partitioning. Early access teams running support bots, batch inference and internal assistants recorded 42-67% lower LLM spend. This feature is live for all gateway users today, with no required code changes to existing routing workflows. (120 words)
out 1041 tok (+872 thinking) latency 11.4 s
Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.
Use Dola Seed 2.0 Pro in 30 seconds
OpenAI-compatible: swap the base_url, keep your SDK. POST /v1/chat/completions
from openai import OpenAI
client = OpenAI(
base_url="https://synthorai.io/v1",
api_key="sk-syn-...",
)
resp = client.chat.completions.create(
model="Dola-Seed-2.0-pro",
messages=[{"role": "user", "content": "Summarize this diff"}],
reasoning_effort="medium",
)
print(resp.choices[0].message.content)import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://synthorai.io/v1",
apiKey: "sk-syn-...",
});
const resp = await client.chat.completions.create({
model: "Dola-Seed-2.0-pro",
messages: [{ role: "user", content: "Summarize this diff" }],
reasoning_effort: "medium",
});
console.log(resp.choices[0].message.content);curl https://synthorai.io/v1/chat/completions \
-H "Authorization: Bearer sk-syn-..." \
-H "Content-Type: application/json" \
-d '{
"model": "Dola-Seed-2.0-pro",
"messages": [{"role": "user", "content": "Hello"}],
"reasoning_effort": "medium"
}'package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/option"
)
func main() {
client := openai.NewClient(
option.WithBaseURL("https://synthorai.io/v1"),
option.WithAPIKey("sk-syn-..."),
)
resp, _ := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
Model: "Dola-Seed-2.0-pro",
Messages: []openai.ChatCompletionMessageParamUnion{
openai.UserMessage("Summarize this diff"),
},
ReasoningEffort: openai.ReasoningEffortMedium,
})
fmt.Println(resp.Choices[0].Message.Content)
}import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;
import com.openai.models.ReasoningEffort;
OpenAIClient client = OpenAIOkHttpClient.builder()
.baseUrl("https://synthorai.io/v1")
.apiKey("sk-syn-...")
.build();
ChatCompletion resp = client.chat().completions().create(
ChatCompletionCreateParams.builder()
.model("Dola-Seed-2.0-pro")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));About Dola Seed 2.0 Pro
- Release notes highlight stable performance in complex reasoning and long-horizon tasks, including multi-step planning, visual-text reasoning, video understanding, and advanced analysis, and BytePlus calls it the most capable model in the series, a multimodal engine for agent-driven workflows with browser use and computer use, naming content moderation, camera-feed safety monitoring, web research and report drafting, financial analysis, document processing, and customer service as target scenarios.
- It provides deep reasoning, multimodal understanding, visual grounding, and tool calling within a 256K context window and up to 128K output including chain-of-thought, plus prefix and session caching in both implicit and explicit forms.
- Two differences from its smaller siblings are worth knowing before standardizing on it: visual grounding is listed for Pro and not for the newest Lite and Mini builds, while structured output is listed for those two and not for Pro, so schema-constrained responses argue for Lite or Mini instead.
- Thinking.type is enabled by default with no automatic mode, and reasoning_effort runs minimal through high, defaulting to medium; output defaults to 4K against the 128K ceiling.
- Synthorai puts it behind its OpenAI-compatible completions endpoint.
FAQ
Is the Dola Seed 2.0 Pro API free to try?
Yes: new accounts get 10 trial calls and up to $1 in free credit, no card required. At $0.5/M input tokens, that credit alone covers roughly 250 requests of ~8K tokens against Dola Seed 2.0 Pro.
What is Dola Seed 2.0 Pro best at?
General-purpose agentic model for the Agent era; stable on complex reasoning and long-horizon tasks; visual grounding, video understanding, and tool calling. See the About section for the full picture from the vendor's own release notes.
How much does Dola Seed 2.0 Pro cost?
Dola Seed 2.0 Pro costs $0.5 per million input tokens and $3 per million output tokens on Synthorai. That is the provider's list price, with no platform markup. Cached input tokens bill at $0.1/M.
Does Dola Seed 2.0 Pro support prompt caching?
Yes: automatic caching is on by default, with an explicit mode for guaranteed savings. Cached input tokens bill at $0.1/M vs $0.5/M uncached; prompts need a 1,024-token stable prefix to cache. Prompt caching guide →
How do I get access to Dola Seed 2.0 Pro?
Point your existing OpenAI SDK at base_url="https://synthorai.io/v1", set model="Dola-Seed-2.0-pro", and you're done. One API key covers every model on the gateway.
Related models
Compare
Every value on this page is transcribed from the vendor's own documentation, linked above, and carries the date it was checked. Prices are compared across the catalogue; specification values that vendors define differently are shown with the difference stated rather than charted. Nothing here is measured by us, and nothing is scored.