kimi-k2-thinking is a thinking model built by Moonshot AI based on Kimi K2, focused on tasks that require decomposition, verification, and multi-step progress. It combines reasoning with function calling, making it suitable for code debugging, complex problem analysis, and long-form writing. It natively supports a 256K context window, can organize materials through text conversations, and can continue completing tasks using execution results after tools are integrated.
Point the Base URL to api.acedata.cloud, configure your platform API key and the model ID below, and use your compatible SDK or client.
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["ACEDATACLOUD_API_KEY"],
base_url="https://api.acedata.cloud/v1",
)
response = client.chat.completions.create(
model="kimi-k2-thinking",
messages=[{"role": "user", "content": "Hello!"}],
)
print(response.choices[0].message.content)Choose an available protocol for this model. OpenAI SDK uses a Base URL ending in /v1; Anthropic SDK uses the root URL. See each guide for protocol-specific parameters, tools and response formats.
First, clarify this model's input and standard calling method.
Native model features are for model selection; this platform's input limits, available parameters, and billing are subject to this model's API and pricing. Continuous output from Chat Completions uses stream, and the client is responsible for saving message history.
Learn what kimi-k2-thinking can bring to your work.
K2 Thinking focuses on step-by-step reasoning and multi-step instruction handling. When faced with problems involving multiple conditions, you can ask it to first organize the constraints, then develop a solution and check the conclusion. It is suitable for analytical tasks that require explaining the basis for judgments; prompts should clearly state objectives, known conditions, and acceptance criteria rather than providing only a broad topic.
The model can propose function calls during reasoning and continue its analysis based on the returned results. Applications can provide query, calculation, or testing functions, allowing tasks to progress from textual recommendations to result verification. It is responsible for choosing calls and organizing parameters, while actual execution is completed by tools, so execution permissions can be managed separately from the model's reasoning capabilities.
A native 256K context provides room to process longer texts, code snippets, and ongoing discussions. You can submit background materials together with writing requirements and ask for an outline, argumentation, and final draft. When there is a large amount of material, it is recommended to retain section labels and citation locations so conclusions can be traced back to specific paragraphs rather than merely generating a general summary.
Start with specific tasks to find where the model can be effective.
Provide the relevant code, error logs, expected behavior, and runtime environment, and ask the model to identify possible causes, propose changes, and design tests. After connecting testing tools, you can also feed back failure information for further revisions. Deliverables may include patch suggestions, explanations of causes, and a regression test checklist; without execution tools, the output remains a code solution to be verified.
Provide candidate options, resource constraints, and evaluation criteria, and let the model analyze trade-offs item by item, identify missing information, and form recommendations. This is suitable for tasks such as technology selection and project planning, where decisions should not be made based on a single metric. You can request a comparison table, key assumptions, and a next-step validation plan to facilitate team discussion rather than directly accepting a conclusion.
Provide multiple text excerpts, meeting notes, or research notes, specify the audience, sections, and argumentation requirements, and generate a structured report draft. You can first organize the relationships among the materials, then expand and revise section by section. Deliverables should ideally include a summary, main text, and items to be supplemented; real-time information should be obtained through retrieval tools before being incorporated into the analysis.
Choose based on task complexity, input materials, and expected results.
If a task involves multiple constraints, repeated verification, or tool feedback, K2 Thinking is a better fit than usage that only requires generating an answer once. It is the K2 series model specifically designed for thinking and tool collaboration, and should not be confused with K2 0905. For brief rewrites or fixed-format filling, first determine whether the task truly requires such a reasoning process.
kimi-k2-thinking-turbo is an independent public model, not an alias for this model. When switching, use the same set of tasks to compare response experience and result quality without assuming a fixed speed difference. K2.6's thinking switch and K3's reasoning_effort are also not control methods for this model; when migrating, design prompts and parameter configurations separately.
Arrange the input first, then connect it to the appropriate application workflow.
Organize current hypotheses, system logs, and executable read-only diagnostic operations, requiring analysis before requesting tools.
Explicitly select kimi-k2-thinking in the Chat Completions request, and organize the context, materials, and output requirements for this run into messages. First use a clearly scoped task to check the response, then include actual review or test feedback in the next message.
Design tasks directly from the following inputs and acceptance priorities.
Please list the most likely causes and the checks that distinguish them; update the hypotheses after receiving the result of each check, then provide an evidence chain and repair recommendations.
Apply the diagnostic tool parameters and permissions, fill in the actual output, then confirm whether the hypotheses are consistent with the evidence; reasoning models do not obtain system access on their own.
Before formal use, understand the output quality and capability scope.
Answers to common questions about using kimi-k2-thinking.
It is built on Kimi K2, with a focus on step-by-step reasoning and alternating between reasoning and function calls. When choosing, consider whether the task requires multi-step analysis, tool feedback, and continuous revision, rather than treating Thinking as another name for regular K2. Be sure to explicitly use kimi-k2-thinking when calling it.
Do not apply K3's reasoning_effort to this model, and do not apply K2.6's thinking switch either. When using K2 Thinking, organize tasks through clear task boundaries, output requirements, and budget settings; temperature=1.0 is the natively recommended sampling value, not a reasoning intensity level.
In a Chat Completions response, the main text is in message.content, and reasoning content may be in message.reasoning_content. For streaming calls, concatenate the corresponding increments separately to avoid mixing them in the same display area; if tool_calls are returned, handle the tool requests first, then continue retrieving the final answer.
Tool definitions in Chat Completions tell the model which functions are available; they do not execute functions on behalf of the application. After receiving a call, you need to parse the parameters, execute the corresponding tool, and return the result as a tool message. It is recommended to also handle parameter validation, execution errors, and tool permissions.
Submit model=kimi-k2-thinking and messages to /v1/chat/completions. Read regular results from choices[].message.content; use stream to obtain incremental results for streaming calls. Use this platform's API Key, and set the complete base URL according to the SDK you use.
Choose a development approach or application suited to this model and follow its setup guide.
↗OpenAI Chat Completions API
SDK installation, authentication and examples
↗Using Ace Data Cloud with Cherry Studio
Chat client setup · Base URL, API key and model
↗Using Ace Data Cloud with ChatBox
Chat client setup · Base URL, API key and model
↗Input
$0.18per 1M tokens
Official $0.46
Output
$0.73per 1M tokens
Official $1.83
You pay$13,584for 142,800 credits · $0.0951 / credits46% OFF
You're billed in credits. Pick a top-up tier to see its per-credit rate — the larger the top-up, the cheaper each credit.
This is only a basic call example. See the full docs for more parameters and advanced usage.
View Docs