Name: Dola-Seed-2.0 Code API
Brand: ByteDance

Overview

What is Dola-Seed-2.0 Code?

When ByteDance launched the Seed 2.0 series in February 2026, they didn't ship a single all-purpose model and call it done. They shipped four distinct variants — and the Code variant is the one built for engineers. While Seed 2.0 Pro handles everything from deep research to scientific reasoning, Dola-Seed-2.0 Code takes the same powerful foundation and sharpens it specifically for software development tasks: writing clean functions, fixing real bugs, reviewing pull requests, and navigating complex codebases.

The model sits at the intersection of frontier reasoning and practical developer tooling. It's the same core intelligence that earned a Codeforces Elo of 3020 and gold-medal results at ICPC competitions, refined for the everyday work that software teams actually do rather than optimized purely for competitive programming leaderboards.

API Pricing

Input: $0.65
Output: $3.9

What it can actually do

Dola-Seed-2.0 Code is tuned for the full software development lifecycle — not just autocomplete. Here's where it holds its own against the best models available today.

Code Generation

Writes functions, classes, and full modules in Python, TypeScript, Java, Go, Rust, C++, and more. Handles both greenfield and scaffold-driven development.

Bug Detection & Fixing

Locates logic errors, runtime failures, and subtle edge-case bugs across files. Understands context beyond the immediate function being inspected.

PR Review Assistance

Reviews diffs for correctness, style, and potential regressions. Suggests improvements without being prescriptive — useful as a first pass before human review.

Test Writing

Generates unit tests, integration tests, and edge-case coverage. Works well with pytest, Jest, Go testing, and other major frameworks.

Documentation

Writes inline docstrings, README files, API references, and architectural overviews. Adapts tone for internal tooling vs. public-facing libraries.

Multi-step Reasoning

Breaks down complex architecture decisions, explains unfamiliar codebases, and traces execution paths across layered systems.

Benchmark results — where it stands

The Seed 2.0 series publishes its benchmark data openly. The numbers below reflect the family's coding performance, primarily from the Pro and Code variants. Dola-Seed-2.0 Code is tuned from this same foundation.

Benchmark	What it tests	Score
Codeforces Elo	Competitive programming difficulty	3020
SWE-Bench Verified	Real GitHub issue resolution	76.5%
ICPC (5 contests)	International programming competition	Gold
SpreadSheetBench	Structured data manipulation	SOTA
SWE-Evo	Evolutionary code improvement	Top tier
MCP-Mark / BFCL-v4	Tool use and function calling	First tier

Worth being direct about the gaps: on SWE-Bench Verified, Claude Opus 4.5 scores 80.9 and on Terminal Bench, GPT-5.2 leads at 62.4 versus Seed 2.0's 55.8. ByteDance acknowledges these gaps in their own model card — particularly in deep codebase reasoning tasks. What the Code variant compensates with is aggressive price-to-performance and native integration with ByteDance's developer toolchain.

Who it's built for

Dola-Seed-2.0 Code is most valuable in environments where developers need persistent, context-aware code intelligence — not just one-shot generation.

`01` `Enterprise Software Teams`

Teams processing high volumes of code reviews, documentation requests, and ticket-driven bug fixes. The model's strong SWE-Bench Verified score means it handles realistic multi-file, multi-constraint engineering tasks that simpler code models fumble.

`02` `AI-Augmented IDEs and Coding Agents`

The model is natively integrated into Kilo Code and TRAE, ByteDance's VS Code-compatible coding environment. Its 256K context window (on the Pro variant) makes it viable for scanning entire repositories in a single pass — a requirement for true agentic code editing.

`03` `Competitive Programmers & STEM Students`

The Codeforces Elo of 3020 and ICPC gold-medal performance places it at the level of an international-caliber competitive programmer. It's a credible training partner for algorithm-heavy problems in C++ and Python.

Frequently asked questions

Is Dola-Seed-2.0 Code open source?

No. Unlike many Chinese AI models released under MIT licenses, the Seed 2.0 series is proprietary. Access is through ByteDance's commercial API and consumer apps only.

What programming languages does it support?

The model handles all major languages including Python, TypeScript, JavaScript, Java, Go, Rust, C++, and C. The ByteDance team also open-sourced Multi-SWE-bench — a multilingual benchmark covering seven languages — indicating strong attention to cross-language code quality beyond Python.

How is Seed 2.0 Code different from Seed 2.0 Pro?

Both share the same frontier-level foundation. Seed 2.0 Code is fine-tuned specifically for software development workflows: code generation, debugging, PR review, and automated testing. Seed 2.0 Pro is the general-purpose flagship for research, scientific reasoning, and complex agentic tasks.

‍

Uptime and performance

Uptime (7d): 100%

Measured on the AI/ML API gateway across live traffic. Figures are medians unless stated. Last updated 2026-10-12.

Use cases

Dola-Seed 2.0 Code is documented as suited to software engineering work, specifically writing, debugging, reviewing, and reasoning about code at production scale. It is also positioned for developer IDE integrations and CI/CD pipeline automation.

It is described as optimized for real-world development environments, with reliable tool use in common IDEs and strong support for coding workflows. It is additionally described as delivering strong front-end performance and being useful in enterprise coding environments.

It supports agentic task planning and dynamic self-repair for programming tasks. It is also described as useful for image-grounded tool use in coding workflows, including browser-based use cases.

How to use Dola-Seed-2.0 Code API

Install any OpenAI-compatible SDK, point it at api.aimlapi.com/v1, and set the model to bytedance/dola-seed-2-0-code.

import requests

r = requests.post(
    "https://api.aimlapi.com/v1/chat/completions",
    headers={"Authorization": "Bearer " + AIMLAPI_KEY},
    json={
      "model": "bytedance/dola-seed-2-0-code",
      "messages": [
        {
          "role": "user",
          "content": "Hello!"
        }
      ]
    },
)
print(r.json())

const r = await fetch("https://api.aimlapi.com/v1/chat/completions", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.AIMLAPI_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "model": "bytedance/dola-seed-2-0-code",
    "messages": [
      {
        "role": "user",
        "content": "Hello!"
      }
    ]
  }),
});
console.log(await r.json());

curl -X POST https://api.aimlapi.com/v1/chat/completions \
  -H "Authorization: Bearer $AIMLAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"bytedance/dola-seed-2-0-code","messages":[{"role":"user","content":"Hello!"}]}'

OpenAI-compatible — swap the base URL and it works with your existing SDK.