DEV Community: Aman Kumar

How to Use Claude in Cursor and Cline With a Custom OpenAI Base URL (2026 Setup Guide)

Aman Kumar — Thu, 08 Oct 2026 05:56:04 +0000

Cursor and Cline both let you plug Claude in with an Anthropic key. That's the simplest path if you're happy paying Anthropic directly. But plenty of people reach Claude through something else: a company LiteLLM proxy, OpenRouter, or a flat-rate gateway. In those cases the endpoint speaks the OpenAI wire format, and you have to wire it in through each tool's "custom OpenAI base URL" settings.

I set this up for a lot of people (I build one of these gateways, so there's a disclosure at the end), and the same few mistakes come up every time. This guide covers the exact settings as of October 2026, plus a five-minute curl check that catches most problems before you open the editor.

My examples use my own endpoint, https://apiclaw.biz/v1. Swap in your gateway's base URL, key and model IDs, and the steps are the same.

What you need

A base URL that ends in /v1 (or whatever your gateway documents). It shouldn't end in /chat/completions, because the tools append that themselves.
An API key for that gateway. This is not an Anthropic key.
The exact model ID the gateway uses for Claude. Gateways name models differently, for example anthropic/claude-..., claude-..., or a prefixed alias. Copy it from the gateway's model list instead of guessing.

Step 0: sanity-check the endpoint with curl

If curl can't talk to the endpoint, neither can Cursor, and Cursor's error messages are a lot less helpful. Set two variables:

export BASE_URL="https://apiclaw.biz/v1"
export API_KEY="paste-your-key-here"

1. List models and find the Claude IDs:

curl -s "$BASE_URL/models" \
  -H "Authorization: Bearer $API_KEY" | jq -r '.data[].id' | grep -i claude

If you get a 401 here, the key is wrong. If you get a 404, the base URL is wrong.

2. Send one chat completion:

curl -s "$BASE_URL/chat/completions" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"claude-sonnet-5-5","messages":[{"role":"user","content":"Reply with the word ok"}]}' \
  | jq -r '.choices[0].message.content'

3. Check streaming. Both editors stream, so you should see data: chunks arrive one at a time, not all at once at the end:

curl -N "$BASE_URL/chat/completions" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"claude-sonnet-5-5","stream":true,"messages":[{"role":"user","content":"Count to five"}]}'

4. Check a tool call. Agent modes depend on this, and it's the step most likely to break on a half-compatible endpoint:

curl -s "$BASE_URL/chat/completions" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-5-5",
    "messages": [{"role":"user","content":"What is the weather in Pune?"}],
    "tools": [{"type":"function","function":{
      "name":"get_weather",
      "parameters":{"type":"object","properties":{"city":{"type":"string"}},"required":["city"]}
    }}]
  }' | jq '.choices[0].message.tool_calls'

You want a get_weather call with {"city":"Pune"} in the arguments. If all four checks pass, the problem is never "the endpoint". It's the editor config.

Cursor: Override OpenAI Base URL

Cursor's own API key docs put provider keys under Cursor Settings > Models. The custom endpoint goes in the OpenAI section:

Open Cursor Settings → Models and expand the API keys area.
Turn on OpenAI API Key and paste your gateway key, not an OpenAI one. Cursor sends this key to whatever base URL you set next.
Turn on Override OpenAI Base URL and paste the base URL, for example https://apiclaw.biz/v1.
Click Add Custom Model and enter the Claude model ID exactly as your gateway lists it.
Click Verify, then select the model in the chat model picker with Auto turned off.

Four things that trip people up:

Name collisions. If your custom model name matches one of Cursor's built-in names, Cursor may treat it as its own model and refuse to route it through your key. Many gateways offer a prefixed alias for this reason. On my gateway it's the apiclaw/ prefix (for example apiclaw/claude-sonnet-5-5), and other gateways use anthropic/...-style IDs.

The override isn't per model. While it's on, Cursor sends OpenAI-family requests to your URL, including some of its built-in models. Disable the built-in models you aren't using, or switch the override off when you want Cursor's own models back.

Agent mode and request shape. Cursor's agent can send request bodies that a plain /chat/completions handler doesn't expect, so tool calls fail even though chat works. Some gateways run a Cursor-specific endpoint for this. OpenRouter documents /api/v1/cursor, and mine has /cursor. Check your gateway's Cursor page if chat works but agent mode doesn't.

What the key doesn't cover. According to Cursor's docs, custom keys only work with chat models, and Tab completion stays on Cursor's built-in models. On Teams and Enterprise plans, Cursor still charges its own token rate ($0.25 per million tokens) for requests made with your key. Cursor's Zero Data Retention policy doesn't apply to requests made with your own key, and those requests still go through Cursor's servers to build the final prompt.

Cline: the OpenAI Compatible provider

Cline's OpenAI Compatible docs describe the setup. In practice:

Open the Cline panel in VS Code and click the ⚙️ settings icon.
Set API Provider to OpenAI Compatible.
Base URL: https://apiclaw.biz/v1 (or your gateway's). Again, don't add /chat/completions.
API Key: your gateway key.
Model ID: the exact Claude ID from Step 0. Once the URL and key are in, Cline can often fetch the model list for you.
Open Model Configuration and fill in the real numbers:

Field	What to put
Context Window Size	The model's actual input limit from your gateway's model list
Max Output Tokens	The model's actual output limit
Image Support	On, if the model accepts images
Input / Output Price	Optional. These only drive Cline's cost display

Don't skip the context window. Cline uses it to decide when to trim or summarise the conversation, and the generic default for an unknown model is usually wrong for Claude. On my gateway's public model list, the Claude models currently show a 1,000,000-token input window and 128,000 max output tokens, but copy the numbers from yours.

If you use Cline's Plan and Act modes, set the model for both. Otherwise one mode can quietly fall back to a different model.

Troubleshooting map

Symptom	Usual cause
404 on every request	Base URL missing `/v1`, or `/chat/completions` added twice
401 / "invalid API key"	Pasted a vendor key instead of the gateway key, or the key is disabled
"Model not found"	Typo in the model ID, or a built-in name collision in Cursor
Chat works, agent mode fails	The tool-call request shape. Try the gateway's Cursor-specific endpoint
Cline loses track in long tasks	Context Window Size left at the default
Works in curl, not in Cursor	Cursor's Auto mode is still picking a built-in model

Final check

Run one real task: ask the agent to read a file and propose a small edit. Then open your gateway's request log and confirm the model, the token counts, and the endpoint path you expect. Two minutes of reading logs here saves an afternoon of wondering why your bill or quota looks odd.

Disclosure: I build APIClaw, the endpoint used in the examples. The Cursor and Cline steps are the same for any OpenAI-compatible gateway, and only the URL, key and model IDs change.

6 Guardrails That Stopped My Coding Agent From Burning Through API Budget

Aman Kumar — Thu, 08 Oct 2026 03:20:17 +0000

Coding agents are great until you look at the bill. A single "fix the failing tests" task can turn into 40+ model calls, each one re-sending the system prompt, file snippets and the previous tool output. Here are the six guardrails I now put on every agent loop, whichever model or provider sits behind it.

1. Cap iterations per task

Every agent framework has some notion of max steps. Set it explicitly. I use 20-30 tool turns for a normal task and stop the run if it is not converging. An agent that has not fixed a test in 25 turns is usually stuck in a loop, not about to succeed.

MAX_TURNS = 25
for turn in range(MAX_TURNS):
    step = agent.step()
    if step.done:
        break
else:
    log.warning("agent hit turn cap, stopping")

2. Trim tool output before it goes back to the model

The biggest hidden cost is tool output. Do not send the whole test log or the whole file. Send the failing test names, the assertion lines and a diff.

def trim(output: str, limit: int = 4000) -> str:
    lines = [l for l in output.splitlines() if "FAIL" in l or "Error" in l or l.startswith(("+", "-"))]
    text = "\n".join(lines) or output
    return text[-limit:]

3. Route by task type

Use a fast, cheap model for planning, search and summarising, and a frontier model only for the hard edit. With an OpenAI-compatible client this is just a different model string per call:

ROUTES = {"plan": "fast-model-id", "edit": "frontier-model-id", "review": "fast-model-id"}
client.chat.completions.create(model=ROUTES["edit"], messages=msgs)

Get the exact ids from GET /v1/models on whatever endpoint you use; guessing ids is the most common setup failure.

4. Bound retries

Retry 429 and 5xx with exponential backoff, but only a few times, then fail over to a second model or stop. Unbounded retries inside an agent loop multiply spend without multiplying progress.

5. Watch the first real run

Before you leave an agent unattended overnight, watch one real task in the provider's request logs. You will spot runaway context growth, repeated identical calls and wrong model routing in minutes.

6. Pick a billing model you can forecast

Per-token pricing is fair but spiky for loops, because input tokens grow every turn. Two ways to make it predictable:

Budget alerts on your direct vendor account, with a hard monthly limit.
Flat-rate plans, where you pay a fixed monthly fee for a daily request allowance. You are still capped, but the bill does not move with context size. One example is APIClaw, an OpenAI-compatible gateway with flat monthly plans and one key across several model families (disclosure: I build it; it is independent and not affiliated with OpenAI or Anthropic).

If your usage is light or you need a first-party vendor contract, stay on the direct API and use budget alerts.

Checklist

Turn cap set
Tool output trimmed
Cheap model for planning, frontier model for edits
Bounded retries with a fallback
One supervised run checked in the logs
A bill you can predict

What guardrails do you use on your agents? I would love to hear what I am missing.

Claude Max’s 5-Hour Cap Broke My Refactor — Flat-Rate Gateway Setup That Fixed It

Aman Kumar — Wed, 07 Oct 2026 07:45:46 +0000

I was three hours into a messy service split. Claude Code had the right modules open, the migration plan was solid, and then the meter hit the wall. Not a bad prompt. Not a wrong model. Just Claude Max’s 5-hour session window—and behind it, the weekly ceiling—telling me to stop mid-refactor.

If you run coding agents all day, you already know this failure mode. You do not run out of interest in the task. You run out of session shape. Waiting for the window to refill is not a workflow. Enabling usage credits (billed at API rates) or dropping a Console key into the agent turns a predictable subscription into an unpredictable invoice.

This post is a practical guide for developers on Claude Code and Cursor: what Max actually meters (as of late 2026), why per-token APIs sting for agent loops, and how to point your tools at a flat-rate, OpenAI-compatible gateway so you are limited by daily requests—not a rolling five-hour clock.

Capacity disclaimer: Claude subscription capacity below is estimated from published tier levels and session/weekly limits as of 2026. Anthropic does not publish a fixed message count. Treat multipliers as planning estimates, not SLAs. The gateway discussed here (APIClaw) is not affiliated with or endorsed by Anthropic, OpenAI, Cursor, or any model vendor.

What Claude Max actually meters

Claude Pro and Max are built for interactive Claude.ai and Claude Code under a subscription pool:

Plan	Typical price	Rough capacity vs Pro	Session shape
Claude Pro	~$20/mo	1×	Rolling 5-hour window + weekly limit
Claude Max 5×	~$100/mo	~5× Pro per session	Same 5-hour + weekly structure
Claude Max 20×	~$200/mo	~20× Pro per session	Same 5-hour + weekly structure

When the window or weekly pool is exhausted, work stops unless you enable usage credits or move to a Console API key. For light chat that is fine. For agentic loops—plan → edit → verify → re-edit across many files—the cut-off feels arbitrary: the agent was mid-pass, your context was warm, and now you are staring at a cooldown.

Why the “just use the API” fix hurts

The Anthropic Console API removes the interactive five-hour cap. You pay per token instead. For coding agents that is a different kind of pain:

Every turn re-sends large file context.
Agents loop; one “simple” refactor can be dozens of tool calls.
Long sessions and big contexts stack input and output tokens quickly.

At frontier rates, a heavy Opus- or Sonnet-heavy afternoon can feel like it might blow past a Max subscription in a day—or the fear of that bill makes teams throttle their own tools. The invoice is accurate; it is just hard to forecast when an agent decides a task needs twenty more turns.

So the binary most write-ups offer is incomplete:

Max — predictable fee, unpredictable when you get cut off.
Direct API — no interactive session window, unpredictable how much you pay.

You want a third shape: keep agent throughput, keep a fixed monthly cost, and meter something you can plan around.

The third option: flat daily requests behind an OpenAI-compatible URL

That is the niche APIClaw sits in: an independent gateway that puts Claude, OpenAI, Kimi, Qwen, DeepSeek, GLM, and related models behind one key, with a flat monthly price, a daily request allowance, and no per-token meter on the gateway side.

Product facts that matter for setup:

Tagline: Flat-rate OpenAI-compatible AI API gateway
Base URL: https://apiclaw.biz/v1 (OpenAI-compatible /chat/completions)
Plans: roughly $19–$129/mo by daily request tier
Unlimited tokens per request on the gateway (underlying model context limits still apply)
Daily reset at 00:00 UTC — no five-hour session window, no weekly ceiling on top of that daily pool
50 free trial requests, no credit card; paid plans use crypto billing
Not affiliated with Anthropic, OpenAI, or other model vendors

You are still limited—by requests per day, not by a rolling session clock or a surprise token invoice. That is the trade you are making on purpose.

Capacity framing (estimated, not invented)

People ask: “Is this more than Max 5×?” Honest answer: it depends how you count a “request” vs a “message,” and how heavy your model mix is.

Use this planning lens—estimated from published tiers, not fake personal benchmarks:

Claude Max multiplies session/weekly capacity relative to Pro; it still resets on Anthropic’s 5-hour + weekly shape.
APIClaw multiplies daily request headroom across plans and resets once at 00:00 UTC.
A coding agent turn often equals one (or more) API requests with large context. Heavier models consume your daily allowance faster than lighter ones; check each plan’s model-tier details in the dashboard.

Do not treat either product as “unlimited Claude.” Treat them as different meters. If your pain is the session clock, a daily request pool is usually the better shape. If your pain is absolute peak capacity in a short burst, Max 20× may still win for pure Claude.ai interactive use—then you keep Max for chat and route agents elsewhere.

Claude Code setup (two environment variables)

Point Claude Code at the gateway by overriding the Anthropic base URL and auth token:

export ANTHROPIC_BASE_URL=https://apiclaw.biz/v1
export ANTHROPIC_AUTH_TOKEN=your-apiclaw-key

Put those in your shell profile or a project .env that Claude Code loads, then restart the CLI so the new endpoint sticks. Full walkthrough with troubleshooting: Claude Code API setup.

After that, agent turns go to the gateway. You burn daily requests, not a five-hour Max window. When the day rolls over at 00:00 UTC, the pool refills.

Quick smoke test before you trust a long refactor:

curl https://apiclaw.biz/v1/chat/completions \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"claude","messages":[{"role":"user","content":"ping"}]}'

Confirm the call in the APIClaw logs, then run Claude Code as usual.

Cursor: custom OpenAI-compatible provider + `apiclaw/` prefix

In Cursor:

Open Settings → Models.
Add / override the OpenAI-compatible base URL to https://apiclaw.biz/v1.
Paste your APIClaw key.
Select models with the apiclaw/ prefix so Cursor routes through your key instead of a built-in vendor id—for example:

apiclaw/claude-opus-4-8

Step-by-step screens and options: Cursor custom API.

Same key works for Claude Code and Cursor. Same daily pool. Switch models (Claude ↔ GPT ↔ Kimi ↔ Qwen ↔ DeepSeek ↔ GLM) without juggling five vendor dashboards.

The honest catch

Flat-rate is not magic. Be clear-eyed about the quotas:

Daily request caps still exist depending on plan. If you blow through them, you wait for 00:00 UTC or upgrade.
Heavier models draw faster. An Opus-class agent loop burns the daily allowance quicker than a lighter model on the same plan. Pick the model that matches the task; reserve frontier models for the hard passes.
Model context limits still apply. “Unlimited tokens per request” on the gateway means APIClaw is not metering you per token—it does not mean a model suddenly accepts infinite context.
This is a gateway, not Anthropic. Features, latency, and model availability can differ from first-party Console. For compliance-sensitive work, read the docs and decide what must stay on vendor-direct keys.

If those constraints are worse for you than Max’s five-hour clock, stay on Max. If the clock is what keeps breaking deep agent sessions, a daily request pool is usually the better meter.

When this setup is worth it

Reach for a flat-rate gateway when:

You hit Claude Max’s 5-hour or weekly wall during real work, not toy prompts.
Direct API bills (or the fear of them) make you afraid to let agents run.
You want one key for Claude + OpenAI + Kimi + Qwen + DeepSeek + GLM across Claude Code and Cursor.
You prefer crypto billing and a no-card trial to test the path.

Keep Max (or Pro) for interactive Claude.ai if you like the product UI. Route agents and IDE tools through the gateway so a long refactor does not share the same session clock as casual chat.

Soft next step

If you want to try the path without a card: grab the 50 free trial requests at https://apiclaw.biz/ui/signup/, set ANTHROPIC_BASE_URL / ANTHROPIC_AUTH_TOKEN for Claude Code (or the apiclaw/ prefix in Cursor), and see whether a daily request pool fits your agent day better than Max’s five-hour window.

No fake screenshots. No “unlimited Claude” claim. Just a different meter—and for a lot of coding-agent workflows in 2026, that is the whole fix.

Disclaimer: APIClaw is an independent flat-rate OpenAI-compatible AI API gateway. It is not affiliated with, endorsed by, or partnered with Anthropic, OpenAI, Cursor, or any model provider named above. Capacity comparisons are planning estimates only.