Your privacy choices

Allow optional cookies for referral attribution, visit analytics, and Google Ads purchase measurement.

Back to blog
English日本語한국어РусскийTiếng Việt繁體中文中文

StepFun Step 3.7 Flash API for Claude Code: Buy Access and Compare Pricing

StepFunstep-3.7-flashAI AgentsAI CodingMultimodal AI

StepFun released step-3.7-flash on May 29, 2026. Searchers also write this as the StepFun step 3.7 flash model, the step 3.7 model, or simply step 3.7 AI. The practical question is the same: can this route handle agent, coding, tool-use, long-context, image, and video workflows at a cost that is easier to test than many frontier-only stacks?

This is not just another chat model announcement. The interesting part is the combination: a 256K-token context window, sparse MoE architecture, OpenAI Chat Completions compatibility, Anthropic Messages compatibility, open weights, and deployment paths across vLLM, SGLang, Transformers, llama.cpp, and NVIDIA NIM.

For teams building high-frequency agents, coding assistants, long-document processing, screenshot-to-code systems, image or video understanding, invoice extraction, or structured multimodal pipelines, step-3.7-flash is worth adding to the evaluation queue. The usual caveat applies: most performance and benchmark figures available today come from StepFun's official release, model card, and partner platforms. Treat them as vendor-published figures until you validate them on your own tasks.

If your goal is to test the API rather than self-host it today, use these setup pages first: Claude Code API access, LLM Agent API Gateway setup, or Chinese LLM API access for overseas teams. You can also compare LLM API pricing, estimate StepFun route cost, read the API docs, or buy API access for one key across StepFun, GPT, Claude, Kimi, GLM, Qwen, and DeepSeek routes.

The Short Version

step-3.7-flash is an open-weight multimodal reasoning model from StepFun. Official docs describe it as a sparse MoE model with roughly 198B total parameters and about 11B active parameters per token. The model card further breaks that down as a 196B language backbone plus a 1.8B vision encoder. It supports 256K tokens of context, three reasoning effort levels (low, medium, high), and a vendor-claimed peak generation speed of up to 400 tokens per second.

The model is designed for practical production workflows where a system may need to read a lot of context, call tools, inspect visual inputs, generate or fix code, and produce structured output without switching models for every step.

If you are comparing StepFun step 3.7 flash for Claude Code, Codex CLI, OpenClaw, Dify, n8n, or an internal agent workflow, treat it as a model route to benchmark, not as a full agent framework. The endpoint can supply the reasoning call; your stack still owns retries, memory, tools, logging, and evaluation.

Key Specs

Item Detail
Model ID step-3.7-flash
Provider StepFun
Official release date 2026-05-29
Positioning Flagship multimodal reasoning model for agents, coding, and multimodal workflows
Architecture Sparse MoE
Parameters About 198B total, about 11B active
Model card detail 196B language backbone + 1.8B vision encoder
Context window 256K tokens
Reasoning effort low, medium, high
Claimed peak speed Up to 400 tokens/s, according to the vendor
Weights/license Apache-2.0
API compatibility OpenAI Chat Completions, Anthropic Messages

For engineering teams, the most important question is not whether the model looks strong on a public table. The question is whether it can reliably reduce the number of agent steps, pass code tests, preserve constraints in long context, and produce structured outputs that your application can trust.

Why Agent Builders Should Pay Attention

Agent workflows are rarely one-shot prompts. A typical run reads instructions, plans, calls tools, observes results, revises the plan, and produces an answer or patch. That loop needs a model that can hold task state, follow tool schemas, recover from partial failures, and choose the right amount of reasoning for each step.

The 256K context window matters because it can keep more of the working set in one request: system policy, tool descriptions, retrieved documents, previous tool outputs, code snippets, screenshots, and user-provided source material. This can reduce lossy summarization and make long-running agent tasks easier to audit.

The three reasoning effort levels are also useful in production routing:

  • low for classification, routing, simple extraction, and low-risk drafts.
  • medium for ordinary analysis, coding support, and document synthesis.
  • high for cross-file debugging, long-context reasoning, structured transformations, and multi-step plans.

The practical approach is to route by task complexity instead of running every request at the highest setting.

Coding: Start With Tasks You Can Grade

For AI coding, polished prose is not enough. The useful metric is whether the generated patch passes tests, respects the existing codebase, and reduces review effort. step-3.7-flash is a good candidate for tasks such as:

  • finding likely causes from error logs,
  • writing tests for existing functions,
  • reviewing pull request diffs,
  • migrating API calls after a breaking change,
  • turning UI screenshots into component plans or frontend drafts,
  • reading several related files before suggesting a minimal fix.

Do not rely only on broad coding benchmarks. Build a small internal set from real issues, real pull requests, CI failures, frontend screenshots, and your own style rules. Track pass rate, edit distance after human review, first-token latency, total task cost, JSON or schema error rate, and whether the result survives code review.

Multimodal Workflows: From Seeing to Doing

The model's multimodal positioning is especially interesting for workflows where visual input has to become structured output. Rather than asking a model to merely describe an image, you can test whether it can perform work:

  • screenshot to code: generate HTML/CSS, React component outlines, or UI section maps;
  • invoice to table: extract fields from receipts, invoices, order screenshots, and forms;
  • chart to data: identify labels, trends, and approximate values;
  • video or screen recording analysis: summarize user actions and spot abnormal states;
  • form understanding: extract fields, validation rules, and completion status.

These tasks need real evaluation data. Clear screenshots, blurred scans, multilingual invoices, dense tables, and low-quality recordings behave very differently. A practical benchmark should include a small golden set and measure field-level accuracy, output format stability, and manual review time.

API Access, Regions, and Pricing

StepFun lists two regional API bases:

  • China region: https://api.stepfun.com/v1
  • International region: https://api.stepfun.ai/v1
  • Model ID: step-3.7-flash

The model supports OpenAI-style Chat Completions and Anthropic-style Messages. For teams already using the OpenAI SDK, Anthropic SDK, Claude Code-style clients, Cursor-style clients, or an internal model gateway, the initial integration is mostly a matter of base URL, model ID, authentication, and a small amount of parameter mapping.

At the time of writing, official pricing is:

Region Input cache miss Input cache hit Output
China CNY 1.35 / 1M tokens CNY 0.27 / 1M tokens CNY 8.1 / 1M tokens
International $0.20 / 1M tokens $0.04 / 1M tokens $1.15 / 1M tokens

For agents and long-context applications, cache-hit pricing deserves special attention. If your system prompt, tool descriptions, schemas, policies, or stable code context can be reused, caching can materially change the cost per task. If every request includes highly variable long context, you still need to model the total cost carefully.

For a Claude Code or coding-agent test, estimate cost by task rather than by chat message. A useful benchmark row includes prompt tokens, output tokens, cache-hit ratio, tool calls, elapsed time, test result, and whether a human needed to rewrite the patch. That makes StepFun step 3.7 flash comparable to Claude, GPT, Kimi, GLM, DeepSeek, and other routes in the same gateway.

Next step: test the API in a real agent stack

If you are evaluating step-3.7-flash for coding agents or multimodal workflows, start with the commercial setup pieces:

OpenAI-Compatible Example

With an OpenAI-compatible client, the basic shape is familiar:

from openai import OpenAI

client = OpenAI(
    api_key="your-stepfun-api-key",
    base_url="https://api.stepfun.ai/v1"
)

response = client.chat.completions.create(
    model="step-3.7-flash",
    messages=[
        {"role": "system", "content": "You are a careful code review assistant."},
        {"role": "user", "content": "Read this error log and suggest the most likely fix: ..."}
    ],
    temperature=0.2
)

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

For the China region, switch the base URL to https://api.stepfun.com/v1. For multimodal inputs, reasoning effort, streaming, and tool calling details, follow the current official API documentation.

Anthropic Messages-Compatible Example

If your application already uses a Claude Messages-style interface, you can test step-3.7-flash with a similar pattern:

import anthropic

client = anthropic.Anthropic(
    api_key="your-stepfun-api-key",
    base_url="https://api.stepfun.ai/v1"
)

message = client.messages.create(
    model="step-3.7-flash",
    max_tokens=2048,
    system="You are a multimodal assistant for frontend engineering.",
    messages=[
        {
            "role": "user",
            "content": "Based on this product screenshot, list the main UI sections and a practical component breakdown."
        }
    ]
)

print(message.content[0].text)

This compatibility is useful for gradual rollout. Start with lower-risk tasks, keep your existing logs, rate limits, fallback strategy, and cost tracking, then expand to more complex agent and multimodal workflows.

Open Weights and Self-Hosting

The model card and weights are published under Apache-2.0, with deployment paths that include vLLM, SGLang, Transformers, llama.cpp, and NVIDIA NIM. That matters for teams with data locality requirements, private infrastructure, latency constraints, or cost models that favor steady self-hosted workloads.

Self-hosting is not automatically cheaper. You need to account for GPUs, serving engineering, concurrency, monitoring, caching, multimodal preprocessing, version upgrades, and failover. A realistic path is to benchmark through the API first, then decide whether volume, compliance, or latency justifies private deployment.

How to Evaluate It Safely

The safest way to introduce step-3.7-flash is to treat it as one route in a unified LLM API gateway or model-routing layer:

  • log model, task type, input length, output length, latency, and cost;
  • select reasoning effort by task complexity;
  • connect coding tasks to test results and code review feedback;
  • measure multimodal tasks with field-level accuracy and review time;
  • keep fallback models so a single route failure does not break the product.

That setup lets you compare step-3.7-flash against your current models on real work instead of relying on launch claims. It also lets customer-facing products expose the model through OpenAI-compatible or Anthropic-compatible endpoints without teaching every feature team a different provider API.

FAQ

Is step-3.7-flash the same as the StepFun step 3.7 model?

Yes. In most search and developer discussions, step-3.7-flash, StepFun step 3.7 flash, step 3.7 model, and step 3.7 AI point to the same StepFun model route. Use the exact model ID required by your provider or gateway when you call the API.

Can I use StepFun step 3.7 flash with Claude Code?

Use a Messages-compatible gateway or client configuration if your Claude Code workflow expects an Anthropic-style Messages endpoint. Validate a small task first, then compare latency, patch quality, rate-limit behavior, and total token cost against your current Claude route.

Is StepFun step 3.7 flash good for agent coding workflows?

It is worth testing for agent coding workflows because it combines long context, multimodal input, reasoning effort control, and API compatibility. Do not judge it from a single chat answer. Measure whether it can pass tests, preserve constraints, and reduce human review time in your own repo.

How should I estimate StepFun API pricing for agents?

Estimate cost per completed task: input tokens, output tokens, cache misses, cache hits, retries, and failed attempts. Long-context agents can look cheap per million tokens but still become expensive if they resend unstable context or retry often.

Ready to test Step-3.7-Flash in a live stack

If you want to move from model evaluation to a working route, use these pages as the practical next step:

Bottom Line

step-3.7-flash is interesting because of the full package: 256K context, multimodal understanding, sparse MoE design, reasoning effort control, OpenAI and Anthropic-compatible APIs, and open weights. It should be considered for agents, coding, long-document workflows, and visual structured extraction.

Whether it belongs in production depends on your own benchmark: test pass rate, structured output reliability, latency, cost, and the amount of human correction it saves. Use the official numbers as a starting signal, not as a substitute for evaluation on your real workloads.

References