1. What Is a Token?

A Token is the smallest basic unit that a Large Language Model (LLM) uses to process text. Think of it as the “atomic vocabulary” the model uses to “read” and “write” — the model doesn’t process Chinese characters or English letters directly, but breaks them into token sequences.

Tokenization Examples

Why Tokens?

• Models only process numbers: LLMs are neural networks; all input must be converted to numerical vectors first. Tokens bridge text to numbers.
• Unit of billing: APIs charge by token count — pay for what you use, transparent and fair.
• Context window metric: The maximum amount of content a model can “remember” at once is measured in tokens (e.g., 128K tokens).

2. How Tokens Are Consumed During an LLM Call

A complete LLM call consumes tokens across three stages:

2.1 System Prompt

The developer-defined “role setting,” such as “You are a professional legal advisor.” It is re-counted every call into input tokens. The longer the system prompt, the higher the fixed cost per conversation.

system_prompt = "You are a geological modeling expert. Use professional terms."
# This prompt is ~10-15 tokens, consumed every conversation

2.2 Input Tokens (Prompt Tokens)

All text content sent to the model, including:

• User message body
• Conversation history (prior Q&A rounds are re-sent in multi-turn chats)
• Uploaded file content (e.g., PDF excerpts, code files)
• Function calling results (tool return values)

2.3 Output Tokens (Completion Tokens)

The text the model generates in response. Output tokens are counted based on actual generation, limited by the max_tokens parameter.

2.4 Complete Consumption Flow

┌─────────────────────────────────────────────────┐
│  Token Bill for One API Call                      │
├─────────────────────────────────────────────────┤
│  Input Tokens (what you send to the model)        │
│  ├── System Prompt                                │
│  ├── User Message (current question)              │
│  ├── Conversation History (prior Q&A rounds)      │
│  └── Tool/File Context (if any)                   │
├─────────────────────────────────────────────────┤
│  Output Tokens (model's response)                 │
│  └── Full content of model's answer               │
├─────────────────────────────────────────────────┤
│  Total = Input Tokens + Output Tokens             │
│  Cost = Input × Input Price + Output × Output Price│
└─────────────────────────────────────────────────┘

3. Basic Token Pricing Formula

Calculation Example

Using Qwen-Long (input ¥0.5/million tokens, output ¥2.0/million tokens):

# User asks: "Explain what a token is" (~300 tokens)
# Model responds with detailed explanation (~900 tokens)

Input cost  = 300 / 1,000,000 × 0.5 = ¥0.00015
Output cost = 900 / 1,000,000 × 2.0 = ¥0.0018
Total cost  = ¥0.00195 (~0.2 Chinese cents)

# 1,000 calls/day ≈ ¥1.95
# 100,000 calls/day ≈ ¥195

Multi-Turn Token Accumulation

Round 1: Input 500 → Output 800 → Cumulative 1300
Round 2: Input 500+1300=1800 → Output 600 → Cumulative 3700
Round 3: Input 500+3700=4200 → Output 500 → Cumulative 8400
...
Round 10: Input may exceed 20,000 tokens

# Input tokens grow linearly with each turn

4. Qwen Series Pricing Breakdown

Alibaba Cloud’s Qwen series charges by token, with prices varying by model, input length, deployment region, and call mode. Below is the pricing reference for China mainland (Beijing region) as of 2026:

Cost-Saving Tips

5. Additional Factors Affecting Token Consumption

Thinking Mode Token Overhead

# Normal mode
Input 500 tokens → Output 800 tokens → Total 1300 tokens

# Thinking mode (deep reasoning enabled)
Input 500 tokens → Reasoning 1200 tokens + Final answer 600 tokens
→ Output 1800 tokens → Total 2300 tokens
# Cost may be 2-3× of normal mode

6. How to Calculate and Monitor Token Consumption

6.1 Check API Response

Every API response includes a usage field showing the current call’s consumption:

{
  "usage": {
    "prompt_tokens": 350,      // Input tokens
    "completion_tokens": 820,  // Output tokens
    "total_tokens": 1170       // Total
  }
}

6.2 Pre-Estimate with Tokenizer

from transformers import AutoTokenizer

# Load Qwen's tokenizer
tokenizer = AutoTokenizer.from_pretrained(
    "Qwen/Qwen2.5-7B-Instruct", trust_remote_code=True
)

# Estimate input token count
text = "Explain what a token is in simple terms"
tokens = tokenizer.encode(text)
print(f"Input token count: {len(tokens)}")
# Output: ~15-20

6.3 Cost Calculation Function

def calc_cost(input_tokens, output_tokens,
              input_price_per_million=0.8,
              output_price_per_million=4.8):
    """Calculate single-call cost for Qwen 3.5-Plus"""
    input_cost = (input_tokens / 1_000_000) * input_price_per_million
    output_cost = (output_tokens / 1_000_000) * output_price_per_million
    return round(input_cost + output_cost, 6)

# Example
cost = calc_cost(500, 1200)
print(f"Cost: ¥{cost}")  # Cost: ¥0.00616

7. Best Practices for Saving Tokens

1. Streamline system prompts: Remove unnecessary context; every extra token is consumed in every call
2. Control conversation rounds: Long conversation history accumulation is a hidden cost driver; reset conversations periodically
3. Set reasonable max_tokens: Don’t default to 4096 or 8192; set based on actual response length needs
4. Downgrade model for simple tasks: Use Qwen-Long (¥0.5/M tokens) for daily Q&A, Qwen-Max only for complex reasoning
5. Use Batch mode for bulk tasks: Processing large data offline? Batch mode saves 50%
6. Enable streaming: Users can stop mid-generation, avoiding unnecessary lengthy responses
7. Cache high-frequency Q&A: Return cached results directly for identical questions — zero token cost
8. Use free quotas: Activate the Bailian Platform to claim 70M+ free tokens for trial