DEV Community: lbase-novaapi

One Endpoint, Your Whole Toolchain: Running Chinese Frontier Models in Claude Code, Cursor, Cline, Aider and More

lbase-novaapi — Fri, 11 Sep 2026 21:00:39 +0000

The awkward part of using a Chinese frontier model isn't the model. It's wiring the same model into the seven different tools you already have open.

This is the copy-paste version of that setup, for every client I've configured over the last few months. One endpoint, many tools. Scroll to the one you use.

First: the part that matters (base URLs)

Nearly every tool below asks for a "base URL". Getting this wrong is the #1 setup failure, and the rule is annoyingly inconsistent:

Client type	What to enter
OpenAI-compatible clients (Cursor, Cline, LangChain, most GUIs)	`https://api.lbase.com/v1` — with `/v1`
Claude Code / Anthropic SDK clients	`https://api.lbase.com` — without `/v1` (the SDK appends `/v1/messages` itself)

Put /v1 on an Anthropic client and you'll get a 404 on /v1/v1/messages. That's the whole bug 90% of the time.

Claude Code

Two environment variables, no config file:

export ANTHROPIC_BASE_URL="https://api.lbase.com"
export ANTHROPIC_AUTH_TOKEN="sk-your-key"
claude

Want a specific model? Claude Code respects the model env var too:

export ANTHROPIC_MODEL="deepseek-v4-flash"     # or a claude-* name if your gateway maps them

Tip: keep a separate shell profile (or a small wrapper script) for the cheap profile and another for the flagship one. Switching is then one command, and you stop hand-editing configs.

Cursor

Settings → Models → OpenAI API Key, then add a custom model:

Base URL: https://api.lbase.com/v1
Model name: deepseek-v4-flash
Toggle off the models you don't want shown in the picker (Cursor lists a lot of noise by default)

Cursor is chat/completion oriented; for long agentic runs, Claude Code or Cline handle tool-call loops better on non-Anthropic models.

Cline / Roo Code (VS Code)

In the extension settings, choose OpenAI Compatible:

Base URL: https://api.lbase.com/v1
API Key: your sk-...
Model ID: deepseek-v4-flash

Cline's agentic loops are token-hungry. This is exactly where prompt caching pays off — the same system prompt and file context get re-sent every step, and on a cached-input rate the input side is nearly free.

Aider (terminal)

export OPENAI_API_BASE="https://api.lbase.com/v1"
export OPENAI_API_KEY="sk-your-key"
aider --model openai/deepseek-v4-flash

Aider also supports Anthropic-style endpoints if you prefer the Claude model aliases.

Continue.dev

~/.continue/config.json:

{
  "models": [
    {
      "title": "DeepSeek V4.1 (NovaAPI)",
      "provider": "openai",
      "model": "deepseek-v4-flash",
      "apiBase": "https://api.lbase.com/v1",
      "apiKey": "sk-your-key"
    }
  ]
}

Dify / FastGPT / LangChain

All three want an OpenAI-compatible provider. Take any provider you're not using, or add a custom one:

# LangChain
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="deepseek-v4-flash",
    base_url="https://api.lbase.com/v1",
    api_key="sk-your-key",
)

For Dify: Settings → Model Provider → OpenAI-API-compatible, paste the base URL and key, then add deepseek-v4-flash as a model name.

Desktop GUIs (Cherry Studio, ChatBox, Open WebUI)

Same pattern every time: pick "OpenAI" as the provider type, then override the API host with https://api.lbase.com/v1, paste the key, and fetch the model list (they'll pull whatever the endpoint exposes).

One caveat with reasoning models: some GUIs render the model's reasoning_content field inline. That's a client rendering quirk, not a broken response — worth knowing before you file a bug.

The three gotchas that cost the most time

1. Model names change under you. Providers rename models (DeepSeek turned deepseek-v4-flash into deepseek-flash the day V4.1 shipped) and start auto-routing traffic between tiers. If a tool hardcodes an old name, it breaks silently. Gateways help here because the mapping lives server-side: your client keeps sending the name it always sent.

2. Peak/off-peak pricing is real. If your provider bills peak windows (DeepSeek's are Mon–Fri 01:00–04:00 and 06:00–10:00 UTC, at 2x), then "the same request" costs double depending on when a batch runs. Schedule overnight jobs outside those windows; on a large batch that's a straight 50% saving with no code changes.

3. Caching is the biggest lever nobody configures. Cached-input rates are an order of magnitude below cache-miss rates. Agentic tools re-send a stable prefix constantly, so enabling caching changes your bill more than switching models does.

How to verify a setup in 30 seconds

curl https://api.lbase.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-your-key" \
  -d '{"model":"deepseek-v4-flash","messages":[{"role":"user","content":"reply with OK"}],"max_tokens":5}'

A 200 with "choices" means your endpoint, key and model name are all fine — any client problem after that is client-side config, not the gateway.

Full disclosure: I build NovaAPI, the gateway used in these examples — OpenAI/Anthropic-compatible access to Chinese frontier models, PayPal/USDT billing. Every snippet above works with any compatible gateway; the base-URL rules and gotchas are the same regardless of which one you pick.

DeepSeek V4.1 Flash Is Here — and You Can Use It From Claude Code Today

lbase-novaapi — Thu, 10 Sep 2026 19:26:30 +0000

If you follow Chinese AI at all, you know DeepSeek's pricing announcements have been a wild ride this quarter: peak/off-peak billing in August, a big Flash price cut in September, and now — literally today — V4.1 Flash is rolling out, with DeepSeek routing all deepseek-v4-pro traffic to the new model at the new (lower) rate.

Here's the short version of today's news, and then the part that matters for developers outside China: how to actually use it from your existing tools.

What changed today

V4.1 Flash officially launches (2026-09-10, 12:00 Beijing time).
Internally tested to beat V4 Pro on performance, speed, cost, and total response time.
Until V4.1 Pro ships, requests to deepseek-v4-pro are auto-routed to V4.1 Flash and billed at V4.1 Flash rates.
New pricing (per 1M tokens, off-peak / peak): input ¥1 / ¥2, output ¥4 / ¥8 — roughly 30% cheaper than V4 Flash, and far below V4 Pro's old ¥4.5 / ¥13.5.

That's a serious price-to-performance jump. The models are frontier-level, the context window is 1M tokens, and the API speaks both OpenAI and Anthropic dialects natively.

The one annoying thing

DeepSeek's own platform is built for the domestic market. If you're outside China, signing up means dealing with a Chinese phone number for verification, Chinese payment rails, and a docs experience that assumes you live there. A lot of us just want to point our existing clients at the model and go.

That's exactly the gap I built NovaAPI for: a gateway that gives you the same DeepSeek models (V4.1 line included) through a normal international flow — sign up with any email, pay with PayPal or USDT, no Chinese phone number anywhere. It also aggregates Claude-compatible endpoints, so Claude Code talks to it natively. (Full disclosure: this is my project — but the tutorial below works for any OpenAI/Anthropic-compatible gateway.)

5-minute setup: DeepSeek V4.1 from Claude Code

Step 1 — Create an account and a key

Sign up at api.lbase.com/register (any email works).
Top up with PayPal or USDT — the minimum is small, just enough to try it.
Go to API Keys and create a key. Pick the DeepSeek channel when asked.

You'll get something like sk-....

Step 2 — Point Claude Code at it

Claude Code respects the ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN environment variables:

export ANTHROPIC_BASE_URL="https://api.lbase.com"
export ANTHROPIC_AUTH_TOKEN="sk-your-novaapi-key"
claude

That's it. Claude Code will use the Anthropic-compatible endpoint, and NovaAPI maps Claude model names (claude-sonnet-4-6, claude-fable-5, etc.) onto the DeepSeek V4.1 line automatically.

Step 3 — Or use any OpenAI-compatible client (Cursor, Cherry Studio, code)

from openai import OpenAI

client = OpenAI(
    api_key="sk-your-novaapi-key",
    base_url="https://api.lbase.com/v1",
)

resp = client.chat.completions.create(
    model="deepseek-v4-flash",   # serving V4.1 Flash as of today
    messages=[{"role": "user", "content": "Write a quick Python snippet for a retry-with-backoff helper."}],
)
print(resp.choices[0].message.content)

Cursor: Settings → Models → OpenAI-compatible → Base URL https://api.lbase.com/v1.

Step 4 — Verify

curl https://api.lbase.com/v1/models \
  -H "Authorization: Bearer sk-your-novaapi-key"

You'll see the model list. Run a couple of prompts and check your usage page — billing is transparent, pay-as-you-go, in USD.

Why not just call DeepSeek directly?

If you already have a Chinese phone number and a way to pay in CNY, absolutely go direct — it'll be marginally cheaper. NovaAPI is for everyone else, and for people who want:

One key for multiple Chinese models (DeepSeek today, more families coming),
Claude Code / Anthropic-SDK compatibility without shims,
PayPal/USDT billing instead of Chinese payment apps,
No phone verification, no VPN, no WeChat.

A note on pricing and peak hours

DeepSeek bills peak/off-peak (peak = Mon–Fri 01:00–04:00 & 06:00–10:00 UTC). NovaAPI passes the official off-peak price × a transparent multiplier to you, and like DeepSeek, peak-hour requests cost more. The price table on novaapi.lbase.com is always current — check it before you commit a big batch job.

Wrapping up

V4.1 Flash looks like the best price-to-performance point in the DeepSeek lineup right now, and with the Pro auto-routing in place, "deepseek-v4-flash" is secretly a very fast, very cheap flagship. If you've been wanting to try Chinese frontier models but bounced off the phone-number wall — the door is open.

Questions, corrections, or war stories from wiring this into your stack? Drop a comment. I read all of them.

How to Cut Your LLM API Bill by ~80% Without Switching Your Tools

lbase-novaapi — Thu, 10 Sep 2026 19:12:46 +0000

I run Claude Code all day. For a while I assumed the API cost was just the price of doing business — the tooling is excellent, the model is excellent, and the bill is… the bill.

Then I actually did the arithmetic on what a coding assistant costs at frontier-model prices, and it turned out I was paying a premium for capability I don't always need. Here's the breakdown, with real numbers, and where I landed.

The price gap, in one table

Published list prices, per 1M tokens (USD):

	Input	Output
Anthropic Claude Sonnet (list)	$3.00	$15.00
DeepSeek V4.1 Flash (off-peak)	$0.22	$0.66
DeepSeek V4.1 Flash (peak)	$0.44	$1.32

That's roughly 13–14× cheaper on input and 11–23× cheaper on output, depending on the hour. DeepSeek bills peak/off-peak (peak = Mon–Fri 01:00–04:00 and 06:00–10:00 UTC), and off-peak is half price — so batching heavy jobs into off-peak hours cuts the bill in half again.

What that means for a real workload

Say you're a solo developer running a coding assistant for a month:

5M input tokens (system prompts, file context, diffs that keep getting re-sent)
1M output tokens (the model's actual work)

Setup	Monthly cost
Claude Sonnet at list price	$30.00
Claude-compatible endpoint on a Chinese frontier model (e.g. NovaAPI, Sonnet tier)	$6.16
Native DeepSeek V4.1 Flash, off-peak	$1.76

Same tools. Same ANTHROPIC_BASE_URL env var. Same request shape. ~80% cheaper on the managed route, ~94% cheaper if you go direct and stay off-peak.

Scale that to a small team (50M in / 10M out per month) and the difference is ~$300/month vs ~$62/month.

Why is it so much cheaper?

Three reasons, none of them magic:

Chinese lab pricing is aggressive by design. DeepSeek in particular has been cutting Flash-series prices this quarter (an August restructure, a September cut, and now V4.1 Flash, which the vendor says beats their own V4 Pro while costing less).
Efficiency at the architecture level. These are MoE-style models with aggressive KV-cache and context handling. The token price reflects a cheaper serving stack, not a cheaper product decision.
Prompt caching is nearly free. DeepSeek's cached-input rate is $0.007/1M off-peak — effectively nothing. If your client re-sends a stable prefix (Claude Code does), the effective input cost collapses.

The honest caveats

I'm not going to pretend this is a free lunch:

Agentic, long-horizon tasks still favor the Western flagships. If your workflow is "let the model run 40 tool calls and recover from its own mistakes," Claude Opus / GPT-5.x still earn their price. Test on your workload before migrating anything critical.
Quality is workload-dependent. Benchmarks are vendor claims. V4.1 Flash is genuinely strong at code, summarization, and long-context work in my testing; for subtle reasoning chains, verify before you trust.
Peak-hour pricing is real. If your workload runs during Chinese business hours (UTC 01–04, 06–10), you pay 2×.
Data path matters. Your prompts go to a Chinese model provider. Don't send anything you wouldn't send to any third-party API.

The setup that actually works

The practical trick is that you don't have to choose one provider. Because the clients we already use speak configurable endpoints, you can point them anywhere:

# Claude Code, pointed at an Anthropic-compatible endpoint
export ANTHROPIC_BASE_URL="https://api.lbase.com"
export ANTHROPIC_AUTH_TOKEN="sk-your-key"
claude

# Or plain OpenAI SDK
from openai import OpenAI
client = OpenAI(api_key="sk-your-key", base_url="https://api.lbase.com/v1")
resp = client.chat.completions.create(
    model="deepseek-v4-flash",   # served by V4.1 Flash today
    messages=[{"role": "user", "content": "Refactor this function for readability."}],
)

Then use whichever profile makes sense per task: cheap-and-fast for refactors, summaries, test generation and bulk jobs; flagship for hairy architecture work. I keep two shells open with different env vars and that's the whole system.

What I actually spend now

Real numbers from my own usage this month, running a coding assistant and a couple of batch jobs through a Chinese frontier model:

A full evening of interactive coding: 23 requests, 18,174 tokens, ~$0.008
A single complex Claude-compatible request: ~$0.003
A 10k-document summarization batch: a few cents, off-peak

Compare that to a month of Sonnet at list price and the gap is not marginal — it's the difference between "careful with tokens" and "stop thinking about tokens."

When to switch, when not to

Switch (or add a second profile) if:

You're cost-sensitive, or you run high-volume batch/summarization work
Your tasks are code edits, refactors, tests, docs, extraction — not long autonomous chains
You want to experiment widely without watching a meter

Don't switch if:

Your product depends on the strongest available reasoning under long tool-use loops
You need a specific vendor's compliance posture or data residency guarantees
You can't tolerate a third-party gateway between you and the model

Most developers I know end up in the middle: flagship for the hard 10%, cheap frontier models for the other 90%. That split is where the 80% number comes from — it isn't a magic trick, just arithmetic plus tooling that lets you route per task.

Full disclosure: I built NovaAPI, an OpenAI/Anthropic-compatible gateway for Chinese frontier models (PayPal/USDT billing, no Chinese phone number needed). The prices above are DeepSeek's published rates and Anthropic's list rates — check both before you commit to a migration. Questions about specific workloads? Ask in the comments and I'll run the numbers.