How Much To Run AI
Open weights

LongCat-2.5: API Pricing, Agent Setup and Open Weights

LongCat-2.5 is Meituan’s multimodal model for coding and long agent workflows. Try the hosted API before planning a cluster: its limited-time rates are $0.30 per million uncached input tokens, $0.006 for cached input and $1.20 for output. MIT-licensed weights are also available. The model has 1.6 trillion total parameters and about 48 billion active per token; storing the full model is a much larger job than running a 48B dense model.

Content reviewed:

LongCat-2.5 limited-time USD rates: $0.30 uncached input, $0.006 cached input and $1.20 output per million tokens. An assumed 1M uncached input plus 100K output costs $0.42. MIT weights have an NPU cluster deployment example, not a minimum configuration.
Limited-time USD API rates checked 2026-11-11. The $0.42 token example uses uncached input; the NPU cluster is an example deployment.

Use this model

API docs and console

Official model repository

Local tools and guides

Where is LongCat-2.5 useful?

  • Work through repository changes with tools and acceptance tests.
  • Use screenshots, charts and videos as context for a text response.
  • Compare a hosted agent run with an open-weight deployment on supported infrastructure.

Start with the LongCat-2.5 API

Use the exact hosted model name LongCat-2.5. The earlier LongCat-2.5-Preview is a separate release. The official platform provides OpenAI-compatible chat completions and Responses endpoints as well as an Anthropic-compatible Messages route. Your account needs an API key and usable quota.

With your key available locally as LONGCAT_API_KEY, this request asks for a small, checkable coding plan. Inspect the returned answer and usage before connecting a tool executor. A response proposing a command does not execute it: the agent application supplies tool permissions, execution and the next turn.

A bounded first request
curl --fail https://api.longcat.chat/openai/v1/chat/completions \
  -H "Authorization: Bearer $LONGCAT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "LongCat-2.5",
    "messages": [{"role":"user","content":"Plan three tests for a CSV parser that accepts quoted commas."}],
    "max_tokens": 1024,
    "thinking": {"type":"disabled"}
  }'

LongCat-2.5 API prices and task costs

The official pay-as-you-go table lists the following limited-time USD rates on November 11, 2026. It gives no end date. Token packs are a separate purchase option; the table below describes metered API usage.

For an assumed run with one million uncached input tokens and 100,000 output tokens, token charges total $0.42. If 800,000 input tokens qualify for caching and 200,000 remain uncached, the same output brings the total to $0.1848. Cache hits change the input bill; they do not discount generated output.

Add every call in a run, including reasoning, retries and rejected patches. Keep tool hosting and search charges alongside the model bill. A low rate only helps if the complete task produces an answer or change you can accept.

Billed tokensUSD per million tokens
Uncached input$0.30
Cached input$0.006
Output$1.20

Choose thinking and visual inputs for the task

The API allows 1,048,576 tokens across input and output, with max_tokens capped at 262,144. Thinking uses temperature 1.0; non-thinking uses 0.7. Other temperature values are overridden. Begin with a modest output budget and increase it when a task needs longer reasoning or a larger deliverable.

Images use image_url blocks with a public URL or an inline data URL. Video uses video_url with a public URL. The documented limits include 100 images per request at up to 10 MB each, and ten videos at up to 100 MB each, each shorter than an hour. Upload only the material needed to answer the question; large visual inputs consume request capacity and processing time.

Check the context window in Claude Code

A model’s API window and the client’s compaction window can differ. Claude Code assumes 200K tokens for an unrecognized model ID. Its model guide allows CLAUDE_CODE_MAX_CONTEXT_TOKENS to set the window for a custom ID such as LongCat-2.5. Set it for the launch you intend to use, then inspect /status and /context before starting a long task.

Gabriel Anhaia’s November 2 integration article highlights this mismatch and recommends scoping the provider configuration to a separate launch instead of changing every session through user-wide settings. The author explicitly says he had not run LongCat-2.5; this is a documentation-based compatibility analysis, separate from the task tests below.

Set the client window after configuring the official LongCat provider
CLAUDE_CODE_MAX_CONTEXT_TOKENS=1000000 claude --model LongCat-2.5

What do independent creative tasks show?

TOKRACE’s review, updated November 3, tested the released LongCat-2.5 through Claude Code on 15 creative tasks, with Blender and browser tools rendering the results. Its bookshelf kept the requested dimensions and its Chinese poster preserved all six required strings. The quarterly dashboard invented a fiscal year, currency and source; a derivatives video drew the central slopes incorrectly. The current review says the planetary reducer was delivered at the correct scale, but its gear motion still needed repair.

These examples help define what to check: geometry and units for a 3D scene, every label and value for a chart, and the underlying explanation for a teaching video. The review links editable projects, rendered outputs and geometry measurements. It does not establish a success rate or deployment throughput for your workload; compare accepted deliverables and complete bills on your own task.

What does self-hosting LongCat-2.5 require?

The official meituan-longcat/LongCat-2.5 checkpoint is MIT licensed. The model card links to an NPU deployment using SGLang-FluentLLM. Its published W4A4 example targets an Atlas A2 cluster with 194 cards: two for the visual encoder, 64 for prefill and 128 for decode. This is an example deployment scale, not a demonstrated minimum.

That recipe separates encoding, prompt processing and generation. It requires matching CANN, PyTorch and custom kernels, plus network configuration across nodes. Follow the longcat-2.5-npu branch and its companion weight instructions rather than substituting a generic desktop launch command.

For a rough storage perspective, 1.6 trillion parameters at two bytes each would occupy about 3.2 TB before other allocations. Four-bit arithmetic alone gives about 800 GB, before scales, higher-precision components, visual encoding, cache and runtime buffers. These calculations describe weight storage; they do not establish the memory or card count of a working deployment.

Choose a hosted trial or a deployment project

Use the API to measure your own repository task, with a fixed test suite and spending limit. Evaluate how many attempts finish correctly and how much context must be sent again. Consider self-hosting when infrastructure control justifies operating a large cluster and maintaining its serving stack.

For a smaller self-hosted coding model, compare Qwen3.8-27B. For inexpensive repeated routing or extraction calls, compare Muse Ember. Those are different capacity and task choices; run the same acceptance checks before deciding which part of an agent workflow each model should handle.

Before you use it

  • The 48B active-parameter figure describes work per token; the full mixture of experts still needs storage and serving capacity.
  • Limited-time hosted rates and cluster operating costs are separate budgets.

How to get started

Start with a bounded API task, record usage across all attempts and check the result. Use the official NPU recipe when evaluating a self-hosted cluster.

Sources

Sources (12)

Calculators