DEV Community: Hassann

How to Use Claude for Free in 2026: Every Option That Works

Hassann — Tue, 25 Aug 2026 08:06:07 +0000

Claude is free to use in 2026. The permanent free plan at claude.ai includes Claude Sonnet 5—one of Anthropic’s strongest models—without a trial period or credit card. Free options also exist for Claude Code and API testing with Apidog.

Try Apidog today

This guide covers the practical free routes: the official plan, Claude Code guest passes, API starter credits, third-party tools, and cloud-provider trials. For deciding whether to upgrade later, see our Claude Free vs Pro comparison.

Is Claude free?

Yes. The free plan at claude.ai never expires and requires no credit card. As of August 2026, it includes:

Claude Sonnet 5, the default free model since July 2026
Claude Haiku 4.5 for faster, lighter responses
Web search, file uploads, and image inputs
Web, desktop, and mobile access

It does not include Claude Fable 5 or other Opus-tier models. Anthropic’s help center lists Fable 5 as paid-plan only: Pro, Max, Team, and Enterprise.

A short free Fable 5 promotion ran in June 2026 and ended on July 19, 2026. See How to Use Claude Fable 5 for Free for the details.

Free usage is metered. Anthropic does not publish fixed limits, but community testing suggests roughly 15–40 messages per rolling five-hour window. Limits can shrink during peak demand because paid accounts receive priority.

Use the free plan for daily questions, document work, and short coding sessions—not extended back-and-forth agent runs.

Option 1: Use the claude.ai free plan

This is the simplest path:

Go to claude.ai.
Sign up with email or Google.
Start using Sonnet 5.

Free Sonnet 5 is the same model available to paying users, not a reduced version. It handles code generation, document analysis, and multi-step reasoning well; most free users hit quota limits before quality limits.

For more detail, read our guide to using Claude Sonnet 5 for free and our Claude Sonnet 5 benchmarks breakdown.

Stretch your free quota

Front-load context: Long threads consume more capacity because Claude reprocesses the conversation. Start a fresh chat for a new task.
Use Haiku 4.5 for quick questions: Select it in the chat composer when you need speed rather than deeper reasoning.
Watch the rolling window: When you reach the cap, Claude tells you when access resets.

Option 2: Get Claude Code through guest passes

Claude Code is not included in the standard free plan, but guest passes can provide free temporary access.

Anthropic gives Max subscribers a limited number of passes. Each pass can give a new user seven days of Pro-level access, including Claude Code. Ask a colleague with a Max subscription to run /passes in Claude Code, or look for trusted developer-community giveaways.

Keep these constraints in mind:

Passes are typically for new accounts.
Reports indicate a card may be required at redemption, even though the seven-day period is free.
After expiration, the account returns to the free plan rather than automatically upgrading to Pro—but always review the current redemption terms.

For other temporary routes, see a proven way to use Claude Code for free and how to claim promotional Claude Code credits.

Option 3: Use free API credits with Apidog

New accounts at platform.claude.com receive a small starter credit balance. Third-party reports place it at about $5—enough to experiment with Sonnet 5 or Haiku 4.5 through the API.

For all available credit options, read free Claude API access.

Starter credits disappear quickly if you spend them debugging malformed requests. Use Apidog to minimize avoidable API usage:

Import the Anthropic API specification so endpoints, headers, and request schemas are ready to use.
Create one canonical /v1/messages request for each use case.
Inspect and save the response as an example.
Create a local mock server from that saved response.
Develop against the mock, then call the real API only for final verification.

This approach can reduce development API spend by an order of magnitude. See How to Cut Your Claude API Bill. When you move to production, prompt caching can reduce costs further.

Option 4: Access Claude through tools you already use

Several products expose Claude models through free or limited tiers, sometimes without requiring an Anthropic account:

GitHub Copilot: Offers Claude as a selectable model through its subscription and limited free tier.
Poe, DuckDuckGo AI Chat, and Brave Leo: Provide Claude variants with small daily allowances.
Cursor and Windsurf: Include Claude among model options during trials.

These routes are useful for occasional usage or a short evaluation sprint. For Cursor, follow our guide on using Claude Sonnet 5 in Cursor.

Verify the exact model before relying on an integration. Third-party products may route requests to older or smaller Claude models and apply different system prompts than claude.ai.

Option 5: Use cloud-provider trial credits

AWS Bedrock, Google Vertex AI, and Azure AI Foundry all provide Claude models. Each cloud offers trial credits to new accounts, and existing startup or education credits may also cover usage.

Setup varies by platform. Our guide to running Claude Fable 5 on Bedrock, Vertex, and Foundry explains the setup; the same process applies to Sonnet 5.

This requires more setup than the consumer free plan, but it is currently the only free route to Fable 5-class models through trial or existing cloud credits.

What free Claude does not include

Know the limits before planning a workflow around the free tier:

No Fable 5: It is available only on paid plans. On Pro, it uses pay-as-you-go credits rather than the flat subscription allowance. See How to Access Claude Fable 5.
Lower peak-time priority: Free capacity can shrink when demand is high.
Tighter session limits: Large projects and long-running agent workflows will reach limits sooner. Read Claude Fable 5 Rate Limits Explained for how limits differ by tier.

If you consistently hit the limit every week, the $20 Pro plan may be worthwhile. Until then, the free options above cover most individual use cases.

FAQ

Which model does the free Claude plan use in 2026?

Claude Sonnet 5 is the default model, with Haiku 4.5 available for faster replies. See the full Sonnet 5 guide for capabilities and API pricing.

How many messages do free users get?

Anthropic does not publish a fixed number. Community estimates suggest roughly 15–40 messages in a rolling five-hour window, depending on server load and message size.

Can I use the Claude API for free?

New platform.claude.com accounts receive starter credit, and Bedrock, Vertex, and Foundry trial credits can also fund API usage. Use Apidog mock servers so development traffic does not consume real API credits.

Is Claude Code free?

Not through the standard free plan. Guest passes can provide seven free days, Anthropic occasionally offers promotional credits, and starter API credit can fund a few short sessions.

Start free, test smart

The claude.ai free plan is the easiest no-cost way to use a frontier model in 2026: Sonnet 5, no card, and no expiry. Add a guest pass to evaluate Claude Code, and use API starter credits for integration tests.

Put Apidog between your application and the API so mock servers handle development traffic and your free credits go toward calls that matter. Download Apidog for free, then upgrade only when your actual usage requires it.

How to Use NotebookLM in 2026: A Practical Guide to Google's Free Research Tool

Hassann — Tue, 25 Aug 2026 07:34:57 +0000

NotebookLM in 2026: A Practical Guide for Research and API Documentation

NotebookLM turns a pile of documents into something you can question. Upload PDFs, docs, links, and videos, then chat with an AI that answers only from those sources—with clickable citations. In 2026, it can also generate podcast-style audio, narrated video explainers, and mind maps. For more on its research capabilities, see our Deep Research breakdown.

Try Apidog today

This guide covers setup, source limits, useful features, paid tiers, and a developer workflow for working with API documentation. It also reflects the product as of August 2026, based on Google’s official support documentation.

What is NotebookLM, and is it free?

NotebookLM is Google’s source-grounded AI research assistant. The standard tier is free and includes:

100 notebooks
50 sources per notebook
50 chat queries per day
3 Audio Overviews per day
3 Video Overviews per day
10 daily generations of reports, flashcards, quizzes, and mind maps

You need a Google account and a browser, or the mobile app for Android or iOS.

“Source-grounded” is the important distinction. A general chatbot may rely on training data and the open web, which can lead to outdated or fabricated answers. NotebookLM answers from your uploaded sources and cites each claim. If the sources do not answer a question, it says so instead of guessing.

Google has been folding NotebookLM into the Gemini brand during 2026. Official support pages now call it Gemini Notebook, but it remains the same product with the same limits. The app is still available at notebooklm.google.com, and most users still call it NotebookLM.

Set up your first notebook

You can create a useful notebook in about two minutes:

Open notebooklm.google.com and sign in. There is no waitlist or credit card requirement.
Select Create new notebook.
Give the notebook one focused purpose: a research topic, course, API, deal, or project. NotebookLM answers from everything in the notebook, so unrelated sources can reduce answer quality.
Add three or four initial sources.
Wait for NotebookLM to process and index them. Processing takes seconds to a few minutes, depending on file size.
Ask a specific question in the chat panel.
Check the citation numbers and click them to open the relevant passage in the source.
Pin useful answers to the Studio panel as notes.

The core workflow is simple: add sources, ask questions, verify citations, and save useful answers.

Add sources: supported formats and limits

Source quality determines answer quality, so keep these boundaries in mind.

Supported sources

NotebookLM accepts:

PDFs and text files, including scanned documents
Google Docs and Google Slides from Drive
Public website URLs
YouTube videos with captions
Audio files, such as lectures and meeting recordings
Markdown files
Pasted text

For YouTube, NotebookLM reads the transcript rather than the video pixels.

Limits and common problems

The free plan supports 50 sources per notebook. Individual sources have long carried a limit of roughly 500,000 words or 200 MB per file. That is enough for a 900-page PDF, and usually more than enough for a typical project.

Watch for these issues:

Paywalled and login-protected pages cannot be scraped. Export them as PDFs first.
YouTube videos without captions do not provide NotebookLM with readable content.
Google Docs do not sync automatically. Use the sync button on the source when the underlying document changes.
Mixing unrelated material in one notebook can make answers less focused.

Features worth using

NotebookLM includes many features, but four are especially practical.

Audio Overviews

Audio Overviews turn your sources into a podcast-style discussion between two AI hosts. Interactive mode lets you interrupt the episode and ask questions. Before generating an overview, you can focus it on a specific chapter or skip background material.

Free users get three Audio Overviews per day.

Video Overviews

Video Overviews create narrated, slide-style explainers from your sources and offer selectable visual styles. They take longer to generate than audio, but work well when you need to explain material to someone who will not read the original documents.

The free tier includes three Video Overviews per day.

Mind maps

Mind maps generate a branching diagram of the concepts across your sources. They are useful for quickly surveying an unfamiliar topic:

Generate a mind map.
Find a branch you do not understand.
Open it and ask a focused question.
Follow the citations back to the source.

Reports, flashcards, and quizzes

The Studio panel can turn sources into briefing documents, study guides, flashcards, and quizzes. Students can use these for revision, while teams can generate a briefing document before a meeting on an unfamiliar topic.

These features share a pool of 10 generations per day on the free plan.

In 2026, all tiers use Gemini 3 models. Paying for a higher tier increases usage limits; it does not provide a smarter NotebookLM model.

Free vs. paid NotebookLM tiers

Google offers the upper NotebookLM tiers through Google AI subscriptions rather than as a standalone NotebookLM plan. The main difference is volume:

Limit	Free	Google AI Plus	Google AI Pro	Google AI Ultra
Notebooks	100	200	500	500
Sources per notebook	50	100	300	500–600
Chat queries per day	50	200	500	2,500–5,000
Audio/Video Overviews per day	3	6	20	Up to 200 video

Google AI Pro removes the watermark from generated videos in most regions. Ultra also unlocks the cinematic Video Overview style built on Google’s Veo video model.

Google AI Pro costs $19.99 per month, while the Plus tier has been reported at $4.99. Students in several countries have received Google AI Pro free for a year.

The practical approach is to stay on the free tier until a limit affects your work. Heavy users are most likely to hit the 50-chat-per-day limit first; that is when Plus or Pro may become worthwhile.

Developer workflow: use NotebookLM for API documentation

API documentation is a strong NotebookLM use case: it is long, structured, detail-heavy, and difficult to search when you need one specific answer.

Build an API documentation notebook

Create a notebook for the API you are integrating.
Add the provider’s reference documentation as URLs or PDFs.
Include relevant RFCs, such as OAuth 2.0’s RFC 6749.
Add your OpenAPI specification as Markdown or a shareable document.
Ask concrete implementation questions.

Useful prompts include:

“What is the rate limit for the batch endpoint?”
“Which scopes does the refresh flow require?”
“Do any endpoints in our specification return a 429 without a Retry-After header?”
“Which response fields are required for the create operation?”

NotebookLM returns citations to the relevant section of the specification, which is often faster than searching multiple documentation sites. Teams working with Gemini’s own API can use the same workflow to query model parameters and API behavior.

Know what NotebookLM cannot do

NotebookLM reads documents; it does not call API endpoints. It may accurately cite a response schema that your production server stopped honoring several releases ago.

That is where Apidog fits:

Maintain the OpenAPI specification as a living source of truth.
Send real requests to the API.
Validate responses against the schema.
Detect differences between documentation and production.
Re-export the validated specification to NotebookLM when it changes.

Use NotebookLM to understand an API, and Apidog to verify that the API still behaves as documented.

FAQ

Does NotebookLM train on my uploaded data?

Google states that NotebookLM does not use sources, queries, or responses from free and paid personal accounts to train its models. Workspace accounts receive additional contractual data protections. Still, apply normal caution when handling sensitive information because policies can change.

Can I share a notebook?

Yes. Notebooks can be shared like Drive files with viewer and editor roles. Viewers can chat with the sources without modifying them. Public links to Audio Overviews are also supported.

Is there a NotebookLM API?

There was no public NotebookLM API as of August 2026. For programmatic source-grounded answers, use Gemini models directly. Gemini 3 Pro through Ollama is an option for local usage, while Google’s File API supports cloud uploads.

Which languages does NotebookLM support?

Chat and generated outputs work in dozens of languages. You can set the output language independently from the source language. Audio Overviews also support many languages, although non-English voices may be less polished than the English hosts.

Conclusion

NotebookLM’s free tier includes the core product: 50 sources per notebook, cited answers, audio and video generation, and mind maps. Start with one notebook focused on a real problem. Once you are comfortable with the workflow, explore these three real-world scenarios.

If your sources are API documentation, complete the loop with Download Apidog. Design the specification, mock it, test it, and keep the documentation aligned with the API that actually runs.

Is DeepSeek Free? Chat, API Pricing, and Every Free Path in 2026

Hassann — Tue, 25 Aug 2026 07:13:43 +0000

Is DeepSeek Free? Chat, API, and Local Hosting Costs Explained

DeepSeek’s chat app is free, its API is paid but inexpensive, and its model weights are open for self-hosting. Which option is “free” depends on how you use it. For a complete setup guide, see how to use DeepSeek V4.

Try Apidog today

This guide focuses on what costs money in August 2026, using rates from DeepSeek’s pricing page.

Is DeepSeek free?

Yes—depending on the access method:

Web and mobile chat: Free. No subscription, Plus tier, or paywall.
API: Paid, with V4 Flash output starting at $0.66 per million tokens off-peak. New accounts receive no free credit.
Model weights: Free to download and run under an MIT license. You pay only for hardware and electricity.

In short: free for chat, cheap for API development, and free-to-self-host if you have the hardware.

Free chat app: what you get and its limits

The DeepSeek chat app, including its iOS and Android apps, is free. It includes reasoning mode, file uploads, and web search.

The limits are operational rather than commercial:

No published daily message quota
“Server busy” errors and slower responses during traffic spikes
No API access, team workspace, or uptime guarantee
Prompts are processed on DeepSeek’s servers in China under DeepSeek’s privacy policy

Use the chat app for research, drafting, coding questions, and evaluating model quality. Choose local hosting if data handling is a concern.

DeepSeek API pricing

As of August 16, 2026, DeepSeek uses peak and off-peak pricing:

Peak: 01:00–04:00 and 06:00–10:00 UTC on weekdays
Off-peak: Every other hour, at half the peak rate

Prices are per 1 million tokens:

Model	Cache-hit input	Cache-miss input	Output
deepseek-v4-flash	$0.007 off-peak / $0.014 peak	$0.22 / $0.44	$0.66 / $1.32
deepseek-v4-pro	$0.022 / $0.044	$0.66 / $1.32	$1.98 / $3.96
deepseek-v4-flash-vision-exp	$0.007 / $0.014	$0.22 / $0.44	$0.66 / $1.32

Three implementation details reduce spend:

Use prompt caching. Repeated prefixes—such as system prompts and few-shot examples—are billed at the cache-hit rate. On Flash, that is roughly 31× cheaper than a cache miss.
Schedule batch work off-peak. Moving non-urgent workloads outside peak hours cuts API cost in half without changing code.
Use Flash unless Pro is justified. Even at peak, Flash output is $1.32 per million tokens. Use Pro when its quality improvement is worth the 3× premium; see the V4 Pro-0813 API guide.

For example, a chatbot using 10M mostly cached input tokens and 2M output tokens per month on off-peak V4 Flash costs about $1.50/month.

Free and near-free API options

DeepSeek does not offer trial credit, so a truly free API route must come from another provider.

OpenRouter free model pool: OpenRouter offers 20+ free models without a credit card. DeepSeek’s free variants were removed by mid-2026, but OpenRouter’s DeepSeek models remain paid and start at roughly $0.035 per million V4 Flash input tokens. Its 50 free daily requests on other models are useful for testing your integration.
Cloud credits: Signup credits from cloud providers and inference hosts can pay for hosted DeepSeek models temporarily.
A small DeepSeek top-up: A $2 balance can support substantial hobby-scale usage and is the simplest way to access the first-party API.

For current providers and no-cost variants, see how to get a DeepSeek free API key.

Run DeepSeek locally for free

DeepSeek publishes weights on Hugging Face under the MIT license, allowing commercial use, fine-tuning, and redistribution.

The V4 family includes:

V4 Flash: 284B total parameters, with 13B active
V4 Pro: Approximately 1.7T parameters; full weights left preview in August 2026

Hardware is the trade-off:

V4 Flash needs about 33 GB VRAM when heavily quantized, or one 80 GB H100 at FP8.
V4 Pro’s full weights approach 900 GB, making it a datacenter-scale deployment.
For a desktop machine, use a smaller distilled or earlier-generation model instead.

To run a practical reasoning model on consumer hardware, follow this guide to running DeepSeek R1 locally with Ollama.

Local deployment gives you:

No per-token fees
No rate limits
No data leaving your machine

But you manage quantization, GPU capacity, and the serving stack. For production workloads, use tools such as vLLM or SGLang.

Chat vs. API vs. local hosting

Choose this	Best for	Cost	Effort
Chat app	Questions, drafting, and model evaluation	$0	None
API	Products and automations	Cents to a few dollars monthly at hobby scale	Low
Local weights	Privacy, offline use, or existing GPUs	No platform fees; hardware costs apply	High

The API is OpenAI-compatible, so most SDK integrations only require changing the base URL.

Test one real call, mock the rest

Use Apidog to test DeepSeek without wasting tokens during development:

Import an OpenAI-compatible API specification.
Set the base URL to https://api.deepseek.com.
Store your API key in an environment variable.
Send one real request and inspect its parsed response, timing, and streamed tokens.
Capture that response and create a mock server for frontend, CI, integration, and error-state tests.

Your application can then exercise realistic model responses at $0 while only sending live requests when validating real DeepSeek behavior. This is especially useful during peak hours, when API rates double.

FAQ

Is DeepSeek chat unlimited?

DeepSeek does not publish a message cap. In practice, server capacity is the limit, and you may see “Server busy” responses at high-traffic times. For workarounds, see how to use DeepSeek V4 for free.

Does the DeepSeek API have a free trial?

No. New accounts start with a zero balance and no promotional credit. Use a small top-up, an aggregator, or cloud signup credits.

Is DeepSeek open source?

Its weights are released under an MIT license, permitting commercial self-hosting. Its training data and full training pipeline are not published, so it is more precisely described as open-weight.

Can I use DeepSeek for coding without paying?

Yes. Use the free chat app for ad-hoc questions, or run DeepSeek Harness against a local model without API charges. See what DeepSeek Harness is.

Bottom line

DeepSeek is free for chat, inexpensive for API development, and free to self-host if you provide the hardware. Start with chat to evaluate it, move to the API when building, and keep costs low by caching prompts, scheduling batch jobs off-peak, and mocking non-production calls.

Download Apidog to import DeepSeek’s API, validate a real request, and mock the rest for free.

How to Run Any Model in DeepSeek Harness ?

Hassann — Thu, 20 Aug 2026 07:57:32 +0000

DeepSeek Harness (dsh) ships with DeepSeek models, but model providers are configurable. Point a provider block at an OpenAI-compatible endpoint, reference a credential, and run agent sessions against the model behind that URL. This works for local Ollama, company gateways, Qwen through DashScope compatibility mode, and catalog providers such as Anthropic and OpenAI.

Try Apidog today

This guide explains the provider configuration and includes three implementation recipes: local Ollama, a hosted OpenAI-compatible endpoint, and built-in catalog providers. The configuration details come from the official providers guide on the master branch, fetched August 20, 2026.

Note: dsh is a developer preview. The README warns about compatibility-breaking changes, so verify the documentation against the version you have installed before using these settings in production.

If you are new to the harness, start with what DeepSeek Harness is and how it works, then return here for provider setup.

Why change models in an agent harness?

An agent harness runs a loop:

The model plans.
The model calls tools.
The harness returns tool results.
The model continues with the updated context.

The harness owns that loop. The model is replaceable.

Cost

Agent sessions can consume tokens quickly because tool results are added back into context. You can route routine sessions to a cheaper model, use DeepSeek V4-Flash instead of V4-Pro, and keep a frontier model configured for harder tasks.

Data locality

For repositories or prompts that cannot leave your network, point a provider at a model running on your own hardware. Prompts, file contents, and tool outputs stay local while you retain the same harness workflow.

Local development

A local model is useful for plugin development and loop testing. It avoids API costs and network dependency during iteration. Switch back to a larger hosted model when model quality matters.

Provider routes are owned by the dsh-llm-pi-ai plugin. The plugin config catalog describes it as holding the “provider routes this instance owns.”

Configure a provider block

Custom providers live in $DSH_HOME/settings.yaml. You can also create them in the web UI under Settings → Models.

llm-pi-ai:
  providers:
    my-gateway:
      apiKeyEnv: GATEWAY_API_KEY
      api: openai-completions
      baseURL: https://gateway.example/v1
      models:
        - id: legacy-chat
        - id: vision-preview
          input: [text, image]

Provider fields

my-gateway: The provider ID. Treat it as permanent. Choose a stable identifier; the UI display name is configured separately.
apiKeyEnv: The environment variable containing the API key. Store only the variable name in configuration, never the secret itself.
api: The endpoint protocol. Use openai-completions for OpenAI-compatible APIs.
baseURL: The API root URL used by the harness.
models: A list of available model IDs. Each id must match the identifier expected by the endpoint.
input: Declares supported input modalities. Custom models default to text-only. Add input: [text, image] for vision models.
defaultInput: A provider-level input fallback. A model-level input setting overrides it.
compat: Compatibility settings for endpoints that differ from standard OpenAI behavior:
- supportsDeveloperRole: false for backends that reject the developer role.
- maxTokensField: max_tokens for backends expecting the older token-limit field.

You can configure compat at the provider level or per model.

When adding a custom provider through the UI, use Fetch available models if the endpoint implements OpenAI-compatible GET /models. The UI can populate the model list automatically.

Store API keys safely

Secrets are stored write-only in:

$DSH_HOME/.credentials.yaml

After saving a key through the UI, dsh returns only a redacted descriptor. The plaintext value is not shown again.

Keep settings.yaml limited to references such as apiKeyEnv and credential descriptors. This lets you share provider configuration without exposing secrets and rotate keys without editing model settings.

Recipe 1: Run a local model with Ollama

Ollama exposes an OpenAI-compatible endpoint at:

http://localhost:11434/v1

See Ollama’s OpenAI compatibility guide.

Configure it as a custom provider:

llm-pi-ai:
  providers:
    ollama-local:
      apiKeyEnv: OLLAMA_API_KEY
      api: openai-completions
      baseURL: http://localhost:11434/v1
      models:
        - id: gpt-oss:20b
        - id: qwen3

Local setup checklist

Start Ollama.
Pull the model you want to use:

   ollama pull gpt-oss:20b

Confirm the installed model names:

   ollama list

Set a placeholder key for the provider schema:

   export OLLAMA_API_KEY=ollama

Ollama does not require an API key locally, but the dsh schema expects a credential reference.

Verify that Ollama serves models:

   curl http://localhost:11434/v1/models

The model ID in settings.yaml must match the Ollama tag exactly, including its version tag.

For the complete local model workflow, see how to run GPT-OSS using Ollama.

Before configuring dsh, test this endpoint in Apidog:

GET http://localhost:11434/v1/models

If the request returns your model list, the server and base URL are correct. If it fails, fix the Ollama setup before debugging the harness configuration.

Small local models are useful for testing plugins and agent loops, but agent workflows rely heavily on tool calling and long context. Expect weaker planning and less reliable tool use than with larger frontier models.

Recipe 2: Use a hosted OpenAI-compatible endpoint with Qwen via DashScope

Alibaba Cloud Model Studio (DashScope) documents OpenAI compatibility through /compatible-mode/v1. Its OpenAI compatibility page lists regional, workspace-specific endpoints.

For example, a Singapore workspace uses:

https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1

Configure Qwen in dsh:

llm-pi-ai:
  providers:
    qwen-dashscope:
      apiKeyEnv: DASHSCOPE_API_KEY
      api: openai-completions
      baseURL: https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1
      models:
        - id: qwen3-max

Replace {WorkspaceId} with the workspace domain from the Model Studio console.

Set the credential in the environment where dsh runs:

export DASHSCOPE_API_KEY=your_api_key

Check the vendor documentation for current model IDs. For related Qwen API details, see the Qwen 3.8 API guide.

This same configuration pattern works for any vendor with documented OpenAI compatibility:

Moonshot Kimi API
OpenRouter
vLLM deployments
Internal company gateways

Usually, only these fields change:

apiKeyEnv: YOUR_PROVIDER_API_KEY
baseURL: https://your-provider.example/v1
models:
  - id: your-model-id

If you have configured open-source models in Codex, the role is similar: dsh’s provider YAML serves the same purpose as Codex model_providers configuration.

Hosted endpoint compatibility settings

If your provider rejects requests because of roles or token parameters, add compat:

llm-pi-ai:
  providers:
    qwen-dashscope:
      apiKeyEnv: DASHSCOPE_API_KEY
      api: openai-completions
      baseURL: https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1
      compat:
        supportsDeveloperRole: false
        maxTokensField: max_tokens
      models:
        - id: qwen3-max

For vision models, explicitly declare image input support:

models:
  - id: your-vision-model
    input: [text, image]

Custom models are text-only unless configured otherwise.

Recipe 3: Use built-in catalog providers

You do not need a custom provider block for mainstream cloud providers. dsh includes catalog providers for:

DeepSeek
Anthropic
OpenAI

For these providers, setup is primarily API-key configuration.

Other catalog entries use their native authentication flows:

Provider	Authentication
AWS Bedrock	AWS credentials
Google Vertex	ADC project configuration
Azure	API version configuration
Codex	OAuth

Use catalog providers when you want the lowest-friction path to Claude, GPT, or DeepSeek models. Use custom providers for local runtimes, regional vendors, OpenAI-compatible aggregators, and internal gateways.

DeepSeek V4-Pro launched alongside the harness in August 2026. Refer to api-docs.deepseek.com for DeepSeek API details.

Select a model and understand session behavior

Adding a provider makes its models available. Selecting a model under Settings → Models sets the default for new sessions.

Two behaviors matter:

Existing sessions keep their original model. Changing the default does not alter the model used by active or previous sessions.
Deleting the current default provider blocks the composer. You must select another model before continuing.

This session pinning improves reproducibility. For example, when comparing harness behavior in DeepSeek Harness vs Claude Code, each transcript remains tied to the model it started with.

Troubleshooting provider configuration

Wrong or unreachable `baseURL`

Confirm that the endpoint ends at the expected API root:

OpenAI-compatible: /v1
DashScope compatible mode: /compatible-mode/v1

Then test the model route outside dsh:

curl \
  -H "Authorization: Bearer $GATEWAY_API_KEY" \
  https://gateway.example/v1/models

Use Download Apidog to send the same request and inspect the actual status code and response body instead of a wrapped harness error.

For offline development or unstable providers, mock these endpoints in Apidog:

GET  /models
POST /chat/completions

Then point baseURL at the mock server while developing your integration.

Missing or empty environment variable

apiKeyEnv names an environment variable. It does not create it.

If dsh cannot read that variable, requests are sent without valid authentication and usually fail with 401.

Check the variable in the same environment that starts dsh:

echo $GATEWAY_API_KEY
dsh web

A process started from a GUI or service manager may not inherit your shell profile.

Image input does not work

Custom models are text-only by default. Add image support per model:

models:
  - id: vision-preview
    input: [text, image]

Or set it for all provider models:

defaultInput: [text, image]

Unsupported roles or token fields

If your backend rejects a developer role or token limit field, configure:

compat:
  supportsDeveloperRole: false
  maxTokensField: max_tokens

A previously working configuration stopped working

dsh is a developer preview. Pin the version you deploy, read release notes before upgrading, and expect configuration schemas to change.

The deepseek-harness repository is the source of truth.

Model providers are only one part of customization. You can also connect the tools that agents call. See using Apidog CLI inside DeepSeek Harness for that workflow.

FAQ

Does DeepSeek Harness officially support Ollama?

The official provider documentation does not mention Ollama by name. It supports endpoints using the openai-completions protocol, and Ollama documents an OpenAI-compatible API at:

http://localhost:11434/v1

The Ollama example combines those documented pieces. Test it with your installed dsh version because the project is a developer preview.

Where does dsh store API keys?

dsh stores keys write-only in:

$DSH_HOME/.credentials.yaml

The UI returns a redacted descriptor after saving. settings.yaml stores only references such as apiKeyEnv, not plaintext API keys.

Can different sessions use different models?

Yes. Changing the selected model changes the default for new sessions only. Existing sessions continue using the model they started with.

For example, use DeepSeek V4-Flash for routine sessions, switch to a larger model for a difficult task, and keep earlier sessions unchanged.

My endpoint works with curl but fails in dsh. What should I check?

Compare the exact request payloads.

The harness may send a developer role or a newer token-cap field that your backend does not support. Use the documented compatibility settings:

compat:
  supportsDeveloperRole: false
  maxTokensField: max_tokens

Replay the harness-shaped request in an API client to identify which field the backend rejects.

How to Use the Apidog CLI in DeepSeek Harness

Hassann — Thu, 20 Aug 2026 07:56:56 +0000

DeepSeek Harness is a loop. The agent reads your workspace, edits files, runs commands through its bash tool, and decides what to do next based on the output. So why aren’t your API tests in that loop? They sit in Apidog behind a GUI and run when someone remembers to click. The agent never touches them.

Try Apidog today

The fix is one config block. The Apidog CLI is an npm package, apidog-cli, that runs the test scenarios you built in Apidog straight from a terminal. Once the CLI is installed and DeepSeek Harness knows it exists, the agent runs an Apidog scenario the same way it runs your unit tests: fire the command, read the exit code, fix the code if it is red.

There is also a token argument for doing this. An agent that confirms your API still works by re-reading handler code and reasoning about response shapes burns context on every pass. An agent that runs one command gets ground truth back in a few lines. The CLI compresses “is the API correct?” into an exit code, and the agent spends its context on the fix instead.

This guide covers the harness-specific part the generic install guide skips: which instructions file DeepSeek Harness actually reads, how its bash tool executes apidog run, and how to keep the loop honest. If you have not installed the CLI yet, do that first. How to install the Apidog CLI with an AI coding agent walks through the npm install, authentication, and the first run. This article assumes apidog --version prints a number and your machine is authenticated.

Which DeepSeek Harness this is about

DeepSeek Harness, dsh on the command line, is the open-source agent harness DeepSeek released on August 13, 2026, alongside V4-Pro on the API. It is MIT licensed, sits at github.com/deepseek-ai/deepseek-harness, and had climbed past 169k stars as of August 20.

Start it with:

npx @deepseek-ai/dsh web

This serves a local web UI at http://127.0.0.1:3080. Select a workspace—the project directory where you launched it—and the agent works inside it: reading and editing files, running commands, and asking before operations that require approval under the active permission policy.

Two details shape the setup below:

DeepSeek Harness is a developer preview. Its README warns that compatibility-breaking changes will happen. Treat the file names and config keys here as accurate for late August 2026, and re-check the repo docs if something does not load.
Everything in dsh is a plugin built on the Cordis architecture. That makes the key question answerable: which plugin reads project rules, and what files does it load?

For a broader introduction, see what DeepSeek Harness is. For a comparison with the incumbent, see DeepSeek Harness vs Claude Code.

Step 1: put the CLI in `AGENTS.md`

DeepSeek Harness reads workspace instructions through its @deepseek-ai/dsh-agent-instructions plugin. According to the plugin source and the config catalog, the loader walks upward from the session working directory to the project root, marked by .git.

It loads these files in each directory:

AGENTS.md
CLAUDE.md as a fallback
AGENTS.local.md as a local overlay
CLAUDE.local.md as a local overlay

Local overlays load after base files. A user-global AGENTS.md in $DSH_HOME, which defaults to ~/.dsh, applies across projects. Files larger than 1 MiB are ignored.

If your repository already has an AGENTS.md for Codex or a CLAUDE.md for Claude Code, DeepSeek Harness can use it without extra setup. Add an Apidog block like this:

## API testing with the Apidog CLI
- To test the API, run the Apidog scenario. Do not click through the GUI.
- Command: apidog run -t <scenario_id> -e <env_id> -r cli
- Exit code 0 means every assertion passed. Non-zero means a failure; read the report and fix the code.
- The machine is already authenticated. Never add an --access-token flag and never put a token in this file.

Use the repository-level file for real scenario and environment IDs. If you work across projects, use ~/.dsh/AGENTS.md for a general rule such as:

Always verify API changes with the project's apidog run command.

Keep the project-specific IDs in each repository’s own AGENTS.md.

Step 2: get the command from Apidog

Do not guess scenario or environment IDs.

Open the test scenario in Apidog.
Go to the CI/CD tab.
Copy the generated command.
Paste it into your repository’s AGENTS.md.

The generated command looks like this:

apidog run -t 123456 -e 789012 -r cli

The flags are:

-t: test scenario ID
-e: environment ID
-r cli: inline reporter output

The cli reporter is important because it gives the agent output it can read directly. Put the real command from Apidog in AGENTS.md so the agent runs the configured scenario rather than inventing IDs.

Step 3: have the agent run the test

Start a session in the dsh web UI with the correct workspace selected. Because the instruction loader has already included your AGENTS.md, the agent knows the command to run.

After changing API code, ask:

Run the Apidog test scenario and tell me the exit code.

The agent executes the scenario through its bash tool. According to the tool catalog, the default bash tool runs every command in a fresh shell.

That means:

Working directories do not persist between tool calls.
Environment variables do not persist between calls.
Shell functions do not persist between calls.
Commands run from the session workspace unless the tool receives a workdir.

This works well for a self-contained command such as:

apidog run -t 123456 -e 789012 -r cli

Do not rely on the agent running cd some-directory in one command and apidog run ... in the next. If the test must run from a subdirectory, keep the full invocation on one line in your instructions file.

A non-zero command exit is returned with an explicit marker:

[exit code: N]

That preserves the pass/fail signal even if long command output is truncated. Commands can also run under a file sandbox. If the sandbox blocks an operation, dsh reports a policy denial rather than a command failure. A read-only test run should rarely trigger this, but the HTML reporter may need permission to write to ./apidog-reports.

Whether the command requires approval depends on the active permission policy. The web UI asks before operations that require approval under that policy, as described in the user guide. If dsh prompts for apidog run, approve it when the scenario is safe for the target environment.

Step 4: read the report

When a scenario fails, use the CLI output to drive the next edit.

With -r cli, the agent receives an inline breakdown of:

Requests made by the scenario
Assertions evaluated
Failed assertions
Expected versus actual values

For example, a failure may identify a wrong status code, a missing total field, or an incorrect currency code. That is usually enough for the agent to find the relevant handler and make a targeted fix.

To also create a report you can open in a browser or share with a teammate, add the HTML reporter:

apidog run -t 123456 -e 789012 -r cli,html

The html reporter writes a self-contained file to ./apidog-reports. Keep cli in the reporter list so the agent still receives inline output for its edit-test-fix loop.

The loop, end to end

Suppose the agent is editing a checkout handler.

Without the CLI, the loop may end at: “the code looks right.”

With the command in AGENTS.md, the loop becomes:

Edit the handler.
Run the scenario:

   apidog run -t 123456 -e 789012 -r cli

Read the result.
If the command exits with 0, move on.
If it returns [exit code: 1], inspect the failed assertion.
Patch the handler.
Run the scenario again.

The agent can now catch problems such as:

A 500 response where 200 is expected
A missing total field
A wrong currency code

The API contract check becomes part of the same edit-test-fix cycle used for unit tests.

The agent does not need to re-read every route file to reason about whether the API works. The scenario already encodes expected behavior and can be authored visually in Apidog. The agent delegates verification to a deterministic command and uses its context on the fix.

Verify dsh actually ran it

Do not accept a success summary without checking the tool call. Use these three checks.

1. Confirm the command ran

The dsh web UI shows agent tool calls and output in the session. Look for the literal bash call:

apidog run ...

If the agent says it ran tests but no matching tool call appears, ask it to run the command again and show the raw output.

2. Confirm the exit code

Ask directly:

What was the exit code of that apidog run command?

On failure, dsh returns an explicit [exit code: N] marker. If an agent summary says “tests passed” but the command has a non-zero marker, trust the marker.

3. Confirm it used the real scenario

A “scenario not found” error usually means the agent invented or misremembered an ID.

Compare the -t and -e values against:

Your AGENTS.md block
The command generated in Apidog’s CI/CD tab

The IDs in the rules file are the source of truth.

Optional: add the Apidog MCP server for spec access

Running scenarios verifies behavior. If you also want the agent to read your API specification while writing code, use MCP.

As of late August 2026, MCP support is not documented in the DeepSeek Harness core README or user guide. A community plugin, hyqhyq3/dsh-mcp-manager, is available through the dsh-plugin GitHub topic. It provides:

An MCP page in Settings
Support for remote HTTP and local stdio servers
Tools registered as mcp__<name>__*
Per-project server definitions in <workspace>/.dsh/dshmm/mcp.json

You can use it to connect the Apidog MCP server, which exposes API specifications over MCP. This lets the agent inspect an endpoint schema before writing the handler instead of discovering a mismatch only after a scenario fails.

Treat this as an optional layer. Both the host harness and the community plugin can change. The CLI integration remains the load-bearing path because it only needs a shell.

Preview caveats, and where this goes

DeepSeek Harness is moving quickly and explicitly warns about breaking changes. Re-check these details when upgrading:

Instructions plugin file candidates
Bash tool sandbox behavior and reporting
Community MCP plugin configuration

The pattern is portable:

Put a verification command in a rules file.
Use a CLI that returns a clear exit code.
Require the agent to run that command after API changes.

That works in dsh for the same reason it works in Claude Code and other coding harnesses: agents can read command output, but they should not be trusted without it.

So, download Apidog, build one test scenario visually, copy its apidog run command from the CI/CD tab, and add it to your repository’s AGENTS.md. The next time DeepSeek Harness changes API code, it can check its own work before reporting that it is done.

FAQ

Does DeepSeek Harness read AGENTS.md natively?

Yes. The @deepseek-ai/dsh-agent-instructions plugin loads AGENTS.md, with CLAUDE.md as a fallback, from the project root and directories above the session working directory. It also supports AGENTS.local.md and CLAUDE.local.md overlays, plus a user-global AGENTS.md in ~/.dsh.

If you already maintain an AGENTS.md for other agents, dsh can use it unchanged.

Do I need a paid DeepSeek plan to use the Apidog CLI in dsh?

No. The harness is MIT-licensed open source, and you bring your own model. Catalog providers cover Anthropic, OpenAI, Bedrock, Vertex, and Azure. Custom gateways work through settings.yaml, as covered in how to run any model in DeepSeek Harness.

The Apidog CLI is a free npm package. It requires an Apidog test scenario and authentication, not a specific model.

Why does the agent’s second command forget the directory the first one changed to?

This is by design. The default dsh bash tool runs every call in a fresh shell, so cd does not persist between commands.

Pass the tool’s workdir parameter or, more simply, keep the complete apidog run invocation on one line in your rules file.

Can dsh run the scenario without asking me every time?

That depends on the active permission policy. The web UI asks before operations that require approval under that policy. The user guide does not enumerate policy levels, so check Settings in your build to see what your deployment allows.

When dsh prompts, approving an apidog run command against staging is a safe choice for a read-mostly verification step.

DeepSeek Harness vs Claude Code: Which Coding Agent Fits Your Stack?

Hassann — Thu, 20 Aug 2026 06:02:04 +0000

DeepSeek Harness (dsh) landed on August 13, 2026, framed as an open-source alternative to Claude Code. VentureBeat’s launch coverage described it as an “open source rival to Claude Code,” released alongside DeepSeek V4-Pro on the API. One week later, the GitHub repository had roughly 169k stars as of August 20.

Try Apidog today

Stars do not answer the implementation question: should you run your coding workflows with DeepSeek Harness or Claude Code?

The tools make different trade-offs:

DeepSeek Harness: MIT-licensed developer preview, plugin-kernel architecture, local web UI, and multiple model providers.
Claude Code: proprietary, mature coding agent with native MCP, skills, hooks, subagents, permission controls, and multiple interfaces.

This guide compares licensing, setup, model configuration, pricing, maturity, extensibility, permissions, and MCP support. It avoids unverified performance claims. If you are new to dsh, start with what DeepSeek Harness is and how it works.

💡 Both agents write code against APIs, and the output quality depends on the API contract you provide. Keep your specification tested and current with Apidog, whichever agent you choose.

The quick comparison

Dimension	DeepSeek Harness (dsh)	Claude Code
License	MIT, source on GitHub	Proprietary; “All rights reserved,” Anthropic Commercial Terms
Age	Released Aug 13, 2026; developer preview	Generally available, mature product
Stability	README warns of compatibility-breaking changes	Stable release channels, versioned settings
Interface	Local web UI at `127.0.0.1:3080`, plus profile-based CLI modes including headless	Terminal CLI, VS Code, JetBrains, desktop app, web, and mobile
Models	DeepSeek, catalog providers for Anthropic, OpenAI, Bedrock, Vertex, Azure, and OpenAI-compatible endpoints	Claude models only, direct or through Bedrock, Vertex, or Foundry
Pricing	Free harness; pay per token for the API you connect	Claude Pro/Max subscription or usage-based API billing
Extensibility	Everything is a plugin through the Cordis kernel	Plugins, skills, hooks, subagents, Agent SDK
Permissions	Web UI approval prompts under an active permission policy	Six documented modes plus allow/deny rules
MCP	Community plugin: `dsh-mcp-manager`	Native, first-class support

Open source vs proprietary: what MIT changes

DeepSeek Harness is MIT licensed, with third-party dependencies listed in THIRD_PARTY_NOTICES.md. In practical terms, you can:

Inspect the agent loop.
Audit what the harness sends over the network.
Fork and patch the project.
Embed it in commercial internal tooling.
Replace parts of the implementation through plugins.

That matters when source access, auditability, or vendor independence is a requirement.

Claude Code takes the opposite approach. Its public repository is for issues and documentation. Its license states:

© Anthropic PBC. All rights reserved. Use is subject to Anthropic’s Commercial Terms of Service.

You use a supported product and its documented extension points, but you cannot inspect or fork the core implementation.

A practical decision rule:

Choose dsh if the agent must become part of your infrastructure.
Choose Claude Code if you prefer a supported product over maintaining agent internals.

MIT licensing gives you rights, not maintenance guarantees. dsh is still a developer preview.

Interface: local web UI vs multiple surfaces

Start DeepSeek Harness

The dsh quick start launches a local browser interface:

npx @deepseek-ai/dsh web

This starts the UI at:

http://127.0.0.1:3080

To start the server without opening a browser automatically:

npx @deepseek-ai/dsh web --no-open

From the UI, select the workspace that maps to the directory where you launched dsh.

dsh also supports profile-based CLI execution. According to the CLI README, profiles live under:

$DSH_HOME/profiles/<name>

Launch a profile with:

dsh --profile <name>

A headless profile can run a persisted session, print the final response, and exit. This makes automation possible, although the web UI is currently the primary interface.

Plugin management is also profile-scoped:

dsh plugin

This forwards plugin operations to pnpm.

Run Claude Code where you work

Claude Code supports more execution surfaces. Per the official overview, you can use it in:

Terminal
VS Code
JetBrains IDEs
Desktop app
Browser at claude.ai/code
Mobile

For non-interactive scripts, CI, cron jobs, or shell pipelines:

claude -p "prompt"

Use dsh when a local browser workflow fits your project. Use Claude Code when you need to move between IDEs, terminals, web sessions, CI, and mobile.

Model freedom: configure any supported backend in dsh

This is the clearest architectural difference.

dsh is model-agnostic. Its provider documentation includes catalog providers for:

Anthropic
OpenAI
Amazon Bedrock
Google Vertex
Azure

It also supports any OpenAI-compatible endpoint through $DSH_HOME/settings.yaml.

A provider configuration includes:

apiKeyEnv: MY_PROVIDER_API_KEY
api: openai-completions
baseURL: http://localhost:8000/v1
models:
  - name: my-local-model

Keep API credentials in a separate .credentials.yaml file so you can share settings without committing secrets.

This lets dsh work with:

DeepSeek APIs
Anthropic APIs
Hosted OpenAI-compatible APIs
Local model servers
Quantized models running on your own GPU

For a full walkthrough, see how to run any model in DeepSeek Harness.

Claude Code runs Claude models only. You can use Amazon Bedrock, Google Cloud’s Agent Platform, or Microsoft Foundry for infrastructure and billing, but the underlying model remains Claude.

Use dsh when model portability is important. Use Claude Code when you want a tightly integrated Claude-specific agent experience.

Pricing: token billing vs subscriptions

The DeepSeek Harness software itself is free. You pay for inference from whichever provider you configure.

If you use DeepSeek’s API, pricing follows DeepSeek’s per-token rates. VentureBeat reported that V4-Pro, released with dsh, had higher pricing than earlier models.

To call V4-Pro directly, review the DeepSeek V4-Pro-0813 API guide.

Per-token billing works well when usage is light or bursty:

No coding sessions = no inference charges

The trade-off is that long agentic sessions can use an unpredictable number of tokens.

Claude Code is commonly used through:

Claude Pro: $20/month
Claude Max: $100/month or $200/month
Usage-based API billing through the Claude Console

Subscriptions make costs more predictable, although they include usage limits. Anthropic raised weekly limits by 50% in July 2026; see the Claude Code weekly limits increase coverage.

A useful rule of thumb:

Light or intermittent use: per-token pricing may be cheaper.
Daily, heavy use: a subscription may be easier to budget.

Because dsh can connect to Anthropic’s API, the model provider and harness decision can be evaluated independently.

Maturity: developer preview vs established ecosystem

DeepSeek Harness is explicitly a developer preview. Its README states:

THERE WILL BE COMPATIBILITY-BREAKING CHANGES.

Plan accordingly:

Pin your configuration where possible.
Expect settings and plugins to change.
Test upgrades in a non-production workspace.
Avoid building critical workflows without a maintenance plan.

Claude Code has been available to developers since early 2025. Its ecosystem includes:

CLAUDE.md project memory
Auto memory
Skills for reusable workflows
Hooks that run commands around agent actions
Subagents coordinated by a lead agent
Agent SDK
GitHub Actions integration
GitLab CI/CD integration
Scheduled routines

These features are documented and versioned. For another comparison of ecosystem maturity, see Claude Code vs Codex CLI.

dsh has substantial early community activity, with roughly 169k stars and 18.1k forks in its first week as of August 20. That can accelerate plugin development, but it does not remove preview-stage risk.

Extensibility: plugin kernel vs extension points

Both tools are extensible, but at different layers.

DeepSeek Harness: plugins are the architecture

dsh is built on Cordis, a plugin kernel described in the paper A Programming Paradigm for Spatiotemporal Composability.

In dsh, components such as these are replaceable plugins:

Model adapters
Tool registries
Session logging
Agent loop behavior

For example, if you need custom retry behavior for failed tool calls, dsh’s architecture allows you to replace the relevant loop component instead of waiting for a vendor feature.

Discover community packages through the GitHub dsh-plugin topic.

Claude Code: stable extension seams

Claude Code exposes supported extension points:

Plugins
Skills
Hooks
MCP servers
Subagents

You customize behavior without replacing the core agent loop. This is usually safer for teams that prioritize upgrade stability.

Choose dsh if you need to reshape the engine. Choose Claude Code if documented customization points are sufficient.

Permissions: approval prompts vs six documented modes

Coding agents need controls before they edit files, execute commands, or access external services.

dsh’s web UI asks for approval when an operation requires it under the active permission policy. That behavior is documented, but the public documentation does not yet define all policy levels and semantics in detail.

Claude Code’s permission system documents six modes:

default
acceptEdits
plan
auto
dontAsk
bypassPermissions

It also supports:

Fine-grained allow and deny rules by tool or command
Working-directory boundaries
Organization-managed policies
plan mode for exploration without edits
auto mode using a background classifier to review actions
bypassPermissions for sandboxed containers

For regulated repositories, junior-heavy teams, or autonomous CI jobs, Claude Code currently has more documented controls.

MCP: native support vs a community plugin

Model Context Protocol (MCP) lets coding agents access external systems such as databases, ticket trackers, and API specifications.

Claude Code supports MCP natively. MCP servers are a first-class, documented integration, and their tools use the same permission model as other agent actions.

In dsh, MCP is currently provided through the community-maintained dsh-mcp-manager plugin. It provides:

A settings page for MCP configuration
Remote HTTP server support
Local stdio server support
OAuth or static-token authentication
Per-project server configuration
Tool registration with names such as:

mcp__<name>__*

This works, but it is not core functionality and carries community-plugin and preview-stage maintenance risk.

Use Apidog as the API contract layer

For API-focused work, connect your agent to the real API contract instead of relying on generated assumptions.

The Apidog MCP Server gives an MCP-capable coding agent access to your team’s API specification. That helps the agent generate client code against actual endpoints, fields, and schemas.

In Claude Code, connect Apidog through native MCP support.
In dsh, connect it through dsh-mcp-manager.

You can also download Apidog and run its MCP server against the same project directory used by either agent.

A practical workflow looks like this:

Maintain the API specification in Apidog.
Expose it to the agent through MCP.
Ask the agent to implement or update API client code.
Run Apidog CLI regression tests in CI.
Review generated changes before merge.

The same API test suite can validate changes produced by either agent.

Which one should you pick?

There is no universal winner. The right choice depends on your constraints.

Pick DeepSeek Harness if

You need source access, MIT licensing, auditability, or forkability.
You want to use multiple model providers from one harness.
You need OpenAI-compatible local model support.
You want to modify agent internals through plugins.
You can tolerate configuration and plugin churn.

Start with:

npx @deepseek-ai/dsh web

Then test it in a non-critical repository before standardizing on it.

Pick Claude Code if

You need a mature product now.
You work across terminal, IDE, desktop, browser, mobile, and CI.
You require documented enterprise permission controls.
You depend on native MCP integration.
You prefer predictable subscription-based billing.
You are comfortable standardizing on Claude models.

Consider running both during evaluation

A practical approach is to test both against the same repository and API contract:

Run dsh locally.
Configure the model provider you want to evaluate.
Connect both agents to the same Apidog MCP server.
Run the same implementation tasks.
Validate output with the same Apidog CLI regression suite.
Compare maintenance effort, permission behavior, cost, and developer workflow fit.

Whichever agent you choose, keep the API layer reliable with Apidog: one tested specification, available to either agent through MCP, and validated by CLI regression tests after every agent-generated change.

FAQ

Is DeepSeek Harness actually open source, unlike Claude Code?

Yes. dsh is MIT licensed, and its source is available on GitHub, including the agent loop and plugin kernel. Claude Code’s public repository uses an all-rights-reserved notice under Anthropic’s Commercial Terms and does not provide source code you can fork.

Can DeepSeek Harness use Claude models?

Yes. dsh includes catalog providers for Anthropic, OpenAI, Bedrock, Vertex, and Azure, plus custom OpenAI-compatible endpoints through settings.yaml.

The reverse is not true: Claude Code runs Claude models only, whether accessed directly through Anthropic or through Bedrock, Vertex, or Foundry.

Is DeepSeek Harness stable enough for daily work?

It is a developer preview, and the README explicitly warns about compatibility-breaking changes. You can use it for real work, but expect configuration and plugin churn.

Claude Code is the safer option for workflows you cannot afford to rebuild.

Do both agents work with Apidog?

Yes. Apidog’s MCP server exposes your API specification to MCP-capable agents:

Claude Code supports it natively.
dsh supports it through the community dsh-mcp-manager plugin.

The Apidog CLI can also run scripted regression tests from either agent’s terminal workflow. See using Apidog CLI in DeepSeek Harness.

What is DeepSeek Harness (dsh)? The Open-Source Claude Code Rival, Explained

Hassann — Thu, 20 Aug 2026 04:28:51 +0000

DeepSeek shipped something unusual on August 13, 2026: not a model, but the machine that runs one. DeepSeek Harness (dsh) is the company’s official open-source agent harness—the software layer that turns a large language model into a coding agent with a session loop, tool execution, permission checks, and a local web UI. It launched alongside DeepSeek V4-Pro on the API, and VentureBeat framed it as an open-source rival to Claude Code.

Try Apidog today

The developer community reacted quickly. As of August 20, the deepseek-harness repository had roughly 169,000 stars and 18,100 forks—one week after release. That level of interest suggests developers want an agent harness they can inspect, modify, and connect to different models.

What DeepSeek Harness actually is

A harness is everything around the model. The model predicts tokens; the harness decides:

What context the model receives
Which tools it can call
How file edits and shell commands are approved
How multi-step sessions are stored and resumed

Claude Code, Codex CLI, and Gemini CLI are all harnesses wrapped around their vendors’ models. For background on two of those tools, see Claude Code vs Codex CLI.

DeepSeek Harness has three defining properties:

Official: It is a first-party project from DeepSeek AI, not a community wrapper around the DeepSeek API.
Open source: It is MIT licensed, with third-party dependencies documented in the repository’s THIRD_PARTY_NOTICES file. You can inspect the agent loop that operates on your codebase.
Developer preview: The README warns: “THERE WILL BE COMPATIBILITY-BREAKING CHANGES.” Treat that as an operational constraint.

The launch timing also matters. dsh arrived alongside DeepSeek V4-Pro on the API, so the harness and its flagship default model were introduced as a pair. For the model side, see the guide to the DeepSeek V4-Pro API, including endpoints, model IDs, and request examples.

The architecture: everything is a plugin

Most coding-agent harnesses are monolithic. The agent loop, model client, tool definitions, and session store ship as one application. You may be able to configure or extend them, but you cannot replace the core components.

dsh takes the opposite approach. Its design principle is “everything is a plugin,” built on a framework called Cordis. Cordis’s design is described in the paper “A Programming Paradigm for Spatiotemporal Composability.”

In practical terms, components that are usually tightly coupled become replaceable modules:

Model adapter: The plugin that communicates with the LLM API.
Tool registry: The tools available to the agent, such as file editing, shell execution, and search.
Session log: The mechanism for recording and replaying sessions.
Agent loop: The decide-act-observe cycle itself.

This matters when you want to experiment with context management, permission policies, or repository-specific tool sets. With a monolithic agent, you wait for the vendor to implement your idea. With dsh, you can build a plugin.

The trade-off is compatibility risk. A system where every component is replaceable has more ways to break, especially when the project explicitly warns about compatibility-breaking changes. The current trade-off is flexibility now in exchange for stability later.

Quick start: run a local agent

Start the local web UI with one command:

npx @deepseek-ai/dsh web

This launches the UI at http://127.0.0.1:3080 and opens it in your browser. To prevent the browser from opening automatically, use:

npx @deepseek-ai/dsh web --no-open

There is no global install, and account creation is not required as an installation step.

Build from source

To run the project from source:

git clone https://github.com/deepseek-ai/deepseek-harness
cd deepseek-harness
pnpm install
pnpm run build
pnpm dsh web

Complete the first-run setup

The first-run flow has three steps:

Configure a DeepSeek API key. Add it in Settings. Credentials are stored in $DSH_HOME/.credentials.yaml, separate from the main settings file, which stores references to them.
Choose a workspace. Select the project directory where you started dsh. The session composer remains unavailable until a workspace is selected. This gives the agent an explicit scope for the files it can inspect and modify.
Run a task and approve operations. The web UI asks for approval before operations covered by the active permission policy. File writes and shell commands appear as prompts instead of running silently.

Use profiles and headless mode

The web UI is one entry point into the underlying profile system:

dsh web

This is shorthand for:

dsh --profile web

Profiles are stored under:

$DSH_HOME/profiles/<name>

For scripts and CI, use headless mode:

dsh --profile headless "job"

This runs one fresh session, prints the result, and exits.

You can also manage profile plugins through pnpm:

dsh plugin

To inspect the composed configuration without starting the harness:

dsh --dump-config
dsh --dump-default-config

See the CLI README for the complete command reference.

What models can it run?

DeepSeek models are the default, with V4-Pro as the headline pairing. DeepSeek also made its off-peak discount permanent, which affects the cost of running an agent that uses tokens continuously. See the post on the DeepSeek V4-Pro price cut, and consult the official DeepSeek API documentation.

The model adapter is a plugin, so dsh supports more than DeepSeek’s models through two paths:

Catalog providers: Built-in provider entries for Anthropic, OpenAI, Bedrock, Vertex, and Azure, with provider-specific credential handling.
Custom providers: Any OpenAI-compatible endpoint can be registered in $DSH_HOME/settings.yaml with a base URL, an environment variable for the API key, and a model list. This includes local runtimes and API gateways.

Selecting a model makes it the default for new sessions. Each session records the model it started with, so changing models does not obscure your project history.

The providers guide documents the configuration format. For the complete YAML setup for custom endpoints, see how to run any model in DeepSeek Harness.

The plugin ecosystem, one week in

Plugins are discoverable through the dsh-plugin GitHub topic. The community also coordinates through GitHub Discussions and a Discord server.

One week after launch, the ecosystem already includes several categories:

Desktop wrappers: Projects such as deepseek-harness-desktop (Tauri) and dsh_desktop (Windows) package the web UI as native applications. These are community projects, not official DeepSeek releases. Review them carefully because they may access your API keys.
Capability plugins: Community repositories such as dsh-context and dsh-vision-router extend what sessions can see and how requests are routed.
MCP support: The core does not include native Model Context Protocol support as of this writing. The community plugin dsh-mcp-manager adds an MCP Settings page supporting remote HTTP or local stdio servers, OAuth or static-token authentication, tools named with the mcp__<name>__* pattern, and per-project server configuration inside the workspace’s .dsh directory.

The MCP distinction is important. Saying that dsh “supports MCP” is only accurate through the community plugin. The core may support MCP directly in the future, but it does not as of this writing.

Where your API workflow fits

An agent harness ultimately executes API calls:

The model API that powers the agent
The APIs inside the project you provide as its workspace

When dsh writes code against your backend, it relies on the API behavior it can infer from the codebase. If the implementation does not match the specification, the agent may generate code against the wrong contract and fail only at runtime.

A practical workflow is to verify the API surface before giving the repository to the agent:

Design or import the OpenAPI specification.
Test the real endpoints against that specification.
Create mock servers with stable, spec-accurate responses.
Let the agent develop against those mocks while the backend changes.

Apidog covers this API design, testing, and mocking workflow. Working against a verified mock reduces the chance of hallucinated integrations caused by stale code or incomplete endpoint documentation.

There is also a direct integration path. The Apidog MCP Server exposes API specifications to AI tools over MCP. In dsh, connect it through the community dsh-mcp-manager plugin:

Install dsh-mcp-manager.
Register the Apidog MCP Server.
Start a session in the relevant workspace.
Let the agent query the API specification instead of inferring it from source code.

The complete workflow, including CLI-based test runs that the agent can trigger, is covered in using Apidog CLI in DeepSeek Harness.

If you want to prepare the API side first, Download Apidog and import your specification before experimenting with dsh.

Should you try it now or wait?

The right answer depends on how you plan to use it.

Try it now if

You want to understand agent internals. dsh is highly inspectable, and reading a real agent loop is a practical way to learn how coding agents work.
You need model flexibility. The pluggable model adapter supports different hosted and self-hosted providers.
You build developer tooling. The plugin ecosystem is new, so early contributors may have an opportunity to shape it.
You already use DeepSeek’s API. dsh provides a first-party agent experience for V4-Pro.

Wait if

You need a stable daily driver. The compatibility-breaking-change warning means configurations, plugins, and workflows may break between versions.
Your organization requires supported tooling. A developer preview with community plugins has a different risk profile from a generally available product with a support contract.
You expect mature UX. Claude Code has had a longer head start on ergonomics, and a one-week-old preview will not match it in every area.

For most developers, the pragmatic approach is to use both: keep your current agent for production work, run dsh in a side project, and evaluate it before relying on it for critical repositories. For a direct comparison with Claude Code, see DeepSeek Harness vs Claude Code.

FAQ

Is DeepSeek Harness free?

The harness is free and open source under the MIT license. The model may cost money: API usage on DeepSeek’s platform, or through whichever provider you configure, is billed by that provider.

Because the adapter layer is pluggable, you can also connect dsh to a locally hosted model and avoid per-token API charges. See run any model in DeepSeek Harness for the setup.

Does dsh only work with DeepSeek models?

No. DeepSeek models are the default, but the model adapter is a plugin. Catalog providers include Anthropic, OpenAI, Bedrock, Vertex, and Azure. You can also add any OpenAI-compatible endpoint through $DSH_HOME/settings.yaml.

Is DeepSeek Harness safe to run on my codebase?

Safety depends on the permission model, the installed plugins, and your review process.

The web UI requires a workspace before a session can run and prompts before operations that require approval under the active policy. However, dsh is still a developer preview, and community plugins—including desktop wrappers—are third-party code that may handle your API keys.

Review every plugin before installing it, and avoid using the preview on repositories where an accidental edit could cause serious damage.

How is a “harness” different from a model?

The model is the reasoning engine; the harness is the system that lets it act.

Session management, tool calls, file access, permission prompts, and context assembly all belong to the harness. Two agents using the same model can behave very differently because their harnesses implement different tools, policies, and session loops. That is why the harness layer has become a major area of coding-agent development.

Self-Hosting GLM-5.3: Get Ready for the Open-Weights Drop

Hassann — Sun, 16 Aug 2026 15:33:37 +0000

Zhipu AI released GLM-5.3 on August 14, 2026. The key detail for infrastructure teams is the planned open-weights release roughly two weeks later, around August 28, on Zhipu’s Hugging Face organization. Use that window to size hardware, select a serving stack, and capture a regression baseline against the hosted API before the safetensors shards are available.

Try Apidog today

Zhipu reports major gains over GLM-5.2: 50% stronger coding capability, a Terminal-Bench 3.0 increase from 4.6 to 28.3, and agent performance described as “approaching Claude Fable 5,” according to launch reporting. For benchmark context and known gaps versus frontier models, see the GLM-5.3 explainer.

This post focuses on implementation: what to prepare before the weights arrive so you can run GLM-5.3 yourself.

The weights are not downloadable yet. Until they are, use the hosted API as your reference implementation. Capture responses now, then replay the same test collection against your self-hosted endpoint later with Apidog.

TL;DR

GLM-5.3 launched on August 14, 2026. Zhipu says open weights should arrive around August 28 on huggingface.co/zai-org.
According to Z.ai documentation, the GLM-5 family uses a Mixture of Experts architecture with 744B total parameters, roughly 40B active parameters per pass, and a 200K-token context window.
At BF16, weights alone are approximately 1.5 TB. At FP8, they are approximately 744 GB, excluding KV cache.
Previous GLM-5 releases included BF16 and FP8 repositories. Expect a similar GLM-5.3 and GLM-5.3-FP8 release pattern, while community GGUF quants may arrive later.
vLLM and SGLang are the practical day-one serving options. Both expose OpenAI-compatible APIs.
Build a hosted-versus-local regression suite now using Apidog: one collection, two environments, and assertions for response shape and expected content.

What Zhipu is releasing, and when

Zhipu, branded internationally as Z.ai, launched the GLM-5.3 API with a promise to publish open weights around August 28, 2026.

Zhipu says the delay supports its most extensive risk-review process to date. That matters because the model reportedly scored 84.5% on CyberGym, slightly above Claude Mythos 5 and GPT-5.6 Sol. Seeking Alpha describes the release as part of Zhipu’s effort to maintain its open-model position against DeepSeek.

For self-hosting, two release details matter:

The base model is unchanged.

GLM-5.3 is GLM-5 with scaled post-training. The serving architecture should therefore match the GLM-5 and GLM-5.2 family already supported by vLLM and SGLang. No new attention mechanism or tokenizer changes are expected.
The repository pattern is established.

Zhipu’s Hugging Face organization already hosts GLM-5, GLM-5.1, and GLM-5.2, including companion FP8 repositories. GLM-5.2 alone shows 2.69M downloads. Plan for a BF16 safetensors release plus an official FP8 release.

License terms for GLM-5.3 were not confirmed in launch coverage. Read the model card before deploying it in a commercial product.

What 744B total and 40B active means for hardware

The GLM-5 family is a Mixture of Experts model with 744B total parameters, around 40B active parameters per forward pass, and 200K context, according to Z.ai’s GLM-5 documentation.

These are family-level specifications rather than GLM-5.3-specific claims. However, because Zhipu says the base model is unchanged, they are appropriate planning numbers.

MoE models create an important memory-versus-compute split:

Compute resembles a 40B dense model. Only routed experts execute for each token, so inference throughput can be substantially better than a 744B dense model.
Memory resembles a 744B model. All experts must remain addressable. At 2 bytes per parameter, BF16 weights require approximately 1.5 TB. At 1 byte per parameter, FP8 weights require approximately 744 GB. Neither estimate includes KV cache.

Precision	Weight footprint (arithmetic)	Practical deployment target
BF16	~1.5 TB	Multi-node cluster or the largest single-server GPU configurations
FP8, official	~745 GB	High-end multi-GPU server, potentially one node
INT4-class community quants	~370–400 GB	Smaller multi-GPU systems; validate output quality first

If you have a single consumer GPU, full GLM-5.3 weights are not the target deployment. Instead:

Rent GPU capacity for evaluation.
Wait for tested community quantizations.
Keep GLM-5.3 on the hosted API while running smaller open models locally.

The best local LLMs in 2026 guide covers models that fit single-GPU and workstation hardware.

Also treat the 200K context window as a memory decision. KV cache grows with both context length and batch size. Set a deployment-specific context cap before launch rather than defaulting to the model maximum.

Pick a serving stack before the weights land

Three serving paths matter, but they will not all be ready at the same time.

Option 1: vLLM

vLLM is the safest default for GLM-5.3-scale inference. It already supports the GLM-5 family and provides:

MoE routing
Tensor parallelism
Expert parallelism
Multi-GPU and multi-node deployment options
An OpenAI-compatible API server

A release-day command may look like this:

vllm serve zai-org/GLM-5.3-FP8 \
  --tensor-parallel-size 8 \
  --max-model-len 65536 \
  --served-model-name glm-5.3

Treat this as a template, not a production-ready command:

The exact repository name must be confirmed after release.
--tensor-parallel-size depends on GPU count, interconnect, and available memory.
--max-model-len should reflect your KV-cache budget, not just the model’s advertised maximum.

Option 2: SGLang

SGLang is the primary alternative. It is especially relevant for agent workloads that repeatedly send long shared prompts because its radix-tree prefix caching can reduce repeated prefill work.

Like vLLM, SGLang exposes an OpenAI-compatible endpoint. That means you can switch serving stacks without rewriting your application client.

Option 3: llama.cpp, Ollama, and LM Studio

The llama.cpp ecosystem requires GGUF conversions. Those are usually created by the community days or weeks after safetensors weights are released.

This route may eventually make more aggressive quantization practical, but verify quality against your own baseline. Do not assume a community quant behaves like the hosted model.

Prepare the runtime now

Before the release window:

Install vLLM or SGLang.
Test CUDA drivers, container runtime, networking, and GPU visibility.
Dry-run the stack with GLM-5.2 weights if your hardware supports it.
Otherwise, use another available MoE model to validate your deployment path.

Avoid debugging CUDA, NCCL, storage mounts, and model-serving configuration on release day.

Use the hosted API as your baseline

Before self-hosting, record what the reference implementation returns.

The hosted API gives you a comparison point when local outputs differ. Without a baseline, you cannot distinguish between:

Quantization quality loss
A serving-stack configuration issue
A model-loading bug
Normal sampling variance

The hosted API is OpenAI-compatible:

International endpoint: https://api.z.ai/api/paas/v4/chat/completions
Mainland China endpoint: https://open.bigmodel.cn/api/paas/v4/chat/completions
Authentication: Authorization: Bearer <key>

Z.ai’s documentation currently lists glm-5. Confirm the exact GLM-5.3 model ID in the official docs before running production tests.

For regional setup details, use the GLM-5.3 API quickstart.

Start by capturing deterministic-ish baselines with temperature: 0:

curl https://api.z.ai/api/paas/v4/chat/completions \
  -H "Authorization: Bearer $GLM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.3",
    "temperature": 0,
    "messages": [
      {
        "role": "user",
        "content": "Write a Python function that parses RFC 3339 timestamps and returns UTC datetimes. Include error handling for invalid input."
      }
    ]
  }' > baseline-rfc3339.json

Build 20 to 50 baseline prompts from your actual workload:

Code generation and refactoring tasks
Tool-calling and agent loops
Structured JSON output
Long-context summarization
Domain-specific prompts
Security-sensitive transformations

Temperature zero does not guarantee perfectly identical output. It does reduce variance enough that meaningful quality regressions become easier to identify.

Build the regression harness in Apidog

Raw curl scripts work for a single endpoint. They become difficult to manage when you compare hosted and local deployments across multiple quantization levels, context limits, and serving stacks.

A structured test collection gives you repeatability. This is standard API regression testing, similar to the workflow in the API testing guide for QA engineers.

1. Create one collection for all baseline prompts

Create one request per baseline case against the chat completions endpoint.

Because the API shape is OpenAI-compatible, you can use an OpenAI-style schema to validate request structure.

Suggested collection layout:

GLM-5.3 Regression
├── code-rfc3339-parser
├── code-refactor-nested-loops
├── tool-call-weather
├── json-mode-extraction
├── long-context-summary
└── agent-planning

2. Create `hosted` and `local` environments

Configure two environments.

Hosted

base_url = https://api.z.ai/api/paas/v4
api_key = <your GLM API key>
model = glm-5.3

Local

base_url = http://localhost:8000/v1
api_key = local-serving
model = glm-5.3

Use environment variables in every request:

POST {{base_url}}/chat/completions
Authorization: Bearer {{api_key}}

Switching between hosted and local then becomes an environment change rather than a request rewrite.

3. Assert response shape first

Start with stable assertions:

HTTP status is 200
choices[0].message.content is not empty
usage exists and contains sensible token counts
The expected response type is returned

Then add content-level checks that tolerate wording variation.

For a Python-code prompt, examples include:

Response contains "def "
Response contains "datetime"
Response contains "try"

Avoid exact-output equality for generative responses unless you control all relevant decoding settings and have confirmed deterministic behavior.

4. Save hosted responses as fixtures

Save hosted responses as examples or reference fixtures.

On release day:

Start the local GLM-5.3 server.
Switch the collection environment from hosted to local.
Run the collection.
Compare local results with hosted fixtures.
Investigate failures before directing production traffic to the new deployment.

5. Run the collection in CI or from the CLI

Use Apidog’s runner to execute the collection headlessly.

That lets you rerun the same test suite for each change:

FP8 vs INT4 quant
vLLM vs SGLang
32K vs 64K context cap
different tensor-parallel sizes
prefix-caching changes
new model revision

The desired output is a repeatable answer to this question:

Does this local deployment behave sufficiently like the hosted reference for our workload?

Your client code does not need to change

The OpenAI-compatible API convention is the practical advantage of this deployment path.

Your application can switch from hosted GLM-5.3 to local GLM-5.3 through configuration:

import os
from openai import OpenAI

# Hosted: GLM_BASE_URL=https://api.z.ai/api/paas/v4
# Local:  GLM_BASE_URL=http://localhost:8000/v1

client = OpenAI(
    base_url=os.environ["GLM_BASE_URL"],
    api_key=os.environ.get("GLM_API_KEY", "local-serving"),
)

response = client.chat.completions.create(
    model="glm-5.3",
    temperature=0,
    messages=[
        {
            "role": "user",
            "content": "Refactor this function to remove the nested loops: ..."
        }
    ],
)

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

When starting vLLM, set a stable served model name:

--served-model-name glm-5.3

That keeps the model string consistent between hosted and local environments.

Streaming, tool calls, and JSON mode use the same general API surface. However, explicitly regression-test tool calling and streaming. These are common areas where local serving stacks can diverge from hosted behavior.

Cost framing: hosted API versus your own GPUs

Zhipu had not published GLM-5.3-specific API pricing at launch. Check the official pricing page before building a per-token cost model.

The tradeoff is structural:

Deployment option	Main cost model	Best fit
Hosted API	Variable per-token cost	Low or variable traffic, fast evaluation, no infrastructure overhead
Self-hosted	Fixed GPU capacity plus operational cost	Sustained utilization, governance requirements, latency control
Rented GPU evaluation	Temporary hourly cost	Benchmarking before committing to infrastructure

Self-hosting a 744B-class MoE can make sense when:

Sustained traffic is high enough to justify GPU capacity.
Prompts or data must stay inside your network.
You need latency, availability, or deployment control that a shared API cannot guarantee.

For low or uncertain demand, the hosted API is usually the safer cost profile. Renting GPUs for evaluation is also safer than buying hardware for a model you have not validated.

There is also a pricing hedge. Provider pricing can change, as discussed in the DeepSeek API price increase analysis. Open weights give you an alternative path if hosted pricing or availability changes.

Drop-day checklist

Items 1 through 6 are preparation work you can complete before weights are released.

Choose your precision target: BF16, official FP8, or community quantization.
Validate that your accessible hardware can support that tier using the memory ranges above.
Install vLLM or SGLang and dry-run it with GLM-5.2 or another MoE model.
Create a Z.ai API key and confirm the GLM-5.3 model ID in the live docs.
Capture 20 to 50 hosted API baseline responses at temperature zero.
Build an Apidog collection with hosted and local environments plus shape and content assertions.
Decide the maximum served context length for each deployment tier.
Watch huggingface.co/zai-org for GLM-5.3 and GLM-5.3-FP8.
Read the model card and license before commercial deployment.
Download the weights and start the server.
Point the local environment to the serving endpoint.
Run the regression collection.
Diff local outputs against hosted fixtures.
Investigate content-level failures before scaling traffic.
Only then tune quantization, parallelism, prefix caching, and context limits.

FAQ

Can I download GLM-5.3 weights right now?

No. As of August 14, 2026, only the hosted API is live. Zhipu says open weights should arrive around August 28 on the zai-org Hugging Face page, where GLM-5, GLM-5.1, and GLM-5.2 are already available.

Will GLM-5.3 run on a single consumer GPU?

Not at full precision or official FP8 weights. The GLM-5 family’s 744B total parameters require roughly 744 GB at FP8 before KV cache. Even INT4-class community quants are expected to require multiple GPUs.

For single-GPU budgets, run smaller open models locally and keep GLM-5.3 on the hosted API. The local LLM roundup covers practical alternatives.

Which serving framework should I use for GLM-5.3?

Use vLLM as the default choice:

Existing GLM-5 family support
MoE-aware parallelism
OpenAI-compatible server
Multi-GPU and multi-node deployment options

Use SGLang when shared long prefixes are common, such as agent loops that repeatedly resend system prompts and context.

Use llama.cpp, Ollama, or LM Studio later, after community GGUF conversions become available.

Will existing OpenAI SDK code work with self-hosted GLM-5.3?

Yes. Point the SDK’s base_url to your vLLM or SGLang server instead of https://api.z.ai/api/paas/v4.

Keep the same request shape and, if possible, preserve the same model name with:

--served-model-name glm-5.3

Test streaming and tool calling specifically because they are more likely to vary across serving implementations.

Why use the hosted API if I plan to self-host?

The hosted API is your reference implementation.

Without baseline responses, you cannot tell whether a local output difference is caused by:

Aggressive quantization
A server configuration issue
A deployment bug
Normal model behavior

Capture hosted responses now using the GLM-5.3 API quickstart, then make drop day a regression-testing exercise instead of guesswork.

Where GLM-5.3 fits in your stack

GLM-5.3 is a major open-weights coding-model announcement: Zhipu reports first-place open-model results on Terminal-Bench 3.0 and Agents’ Last Exam, a CyberGym score above two frontier models, and a scheduled public weights release.

The teams that benefit first will not necessarily be the teams with the largest GPU budgets. They will be the teams that use the release window to prepare:

Serving stack installed
Precision tier selected
Context limits defined
Hosted baselines captured
Regression harness ready

Start with the checklist. Capture hosted baselines now, then use Apidog to manage one collection across hosted and local environments. That turns “does this deployment work?” into a repeatable pass/fail report whenever you change a quantization level or serving flag.

How to Use the GLM-5.3 API?

Hassann — Sun, 16 Aug 2026 15:32:38 +0000

Zhipu AI, the Chinese lab that operates internationally as Z.ai, released GLM-5.3 on August 14, 2026. Its internal evaluations report a 50% coding-capability improvement over GLM-5.2, with Terminal-Bench 3.0 rising from 4.6 to 28.3. Zhipu describes coding and agent capability as “approaching Claude Fable 5,” according to the BigGo launch report. Open weights are expected about two weeks later. For benchmarks and capability details, see what GLM-5.3 is; this post focuses on getting the API working.

Try Apidog today

This quickstart covers getting an API key, making a cURL request, using Python and Node.js through the OpenAI SDK, streaming output, tuning core parameters, and testing requests in Apidog before wiring them into your application.

The API is OpenAI-compatible. If you already use OpenAI-style chat completions, you primarily need to change the base URL, API key, and model ID.

GLM-5.3 launched recently, so verify model IDs, pricing, and limits against the live Z.ai documentation before deploying.

TL;DR

GLM-5.3 was released on August 14, 2026. Zhipu reports a 50% coding improvement over GLM-5.2 and a Terminal-Bench 3.0 increase from 4.6 to 28.3.
International endpoint: POST https://api.z.ai/api/paas/v4/chat/completions
Mainland China endpoint: POST https://open.bigmodel.cn/api/paas/v4/chat/completions
Authenticate with Authorization: Bearer $GLM_API_KEY.
The GLM-5 docs listed glm-5 at launch. The expected GLM-5.3 ID is glm-5.3, but confirm before hardcoding it.
Test request shapes, regional endpoints, model variables, and reasoning settings in Apidog before writing production code.

Why GLM-5.3 matters

GLM-5.3 is a post-training update on the GLM-5 base model. Zhipu reports that Terminal-Bench 3.0 increased from 4.6 to 28.3, while SWE-Marathon roughly doubled compared with GLM-5.2.

Treat these as vendor-reported results until independently reproduced. For API evaluation, the practical takeaway is simple: test GLM-5.3 on your own coding, shell, agent, and debugging prompts.

The GLM-5 family uses a Mixture of Experts architecture with 744B total parameters, about 40B active parameters per forward pass, and a 200K-token context window, according to Z.ai’s docs. These are GLM-5 family specifications, not necessarily GLM-5.3-specific changes.

Zhipu says it plans to release GLM-5.3 open weights around August 28, 2026, according to Pandaily’s launch coverage. If self-hosting is on your roadmap, use the hosted API now to create a prompt and response regression suite. See the GLM-5.3 self-hosting prep guide for that workflow.

Get an API key

Zhipu operates separate international and mainland China platforms.

Z.ai: international platform

Sign up at z.ai.
Open the API console.
Create an API key.
Use the documentation at docs.z.ai.

This guide defaults to the international endpoint.

Bigmodel.cn: mainland China platform

For mainland China traffic, use open.bigmodel.cn. The request format and authentication scheme are the same, but the hostname and billing are separate.

Store the key in an environment variable:

export GLM_API_KEY="your-key-from-the-console"

Do not commit the key to source control. Add .env files to .gitignore, and use your deployment platform’s secret store in production.

Endpoint and authentication

Use the chat completions endpoint.

International:

POST https://api.z.ai/api/paas/v4/chat/completions

Mainland China:

POST https://open.bigmodel.cn/api/paas/v4/chat/completions

Send your key in the Authorization header:

Authorization: Bearer $GLM_API_KEY

The request and response formats follow the OpenAI chat completions pattern:

Request fields include model and messages.
Responses include choices, message, finish_reason, and usage.
OpenAI Python and Node.js SDKs work after changing the provider base URL.

If you have an existing OpenAI-compatible integration, this is usually a configuration change rather than a rewrite. The same migration pattern applies to DeepSeek V4 Pro’s API.

Keep the model ID configurable

At launch, Z.ai documentation listed glm-5 on the GLM-5 page. Since Zhipu lists glm-5.2 and glm-5.1 separately on its pricing page, glm-5.3 is the expected model ID.

Use an environment variable rather than hardcoding it:

export GLM_MODEL="glm-5.3"

If glm-5.3 is unavailable in your region, confirm the current ID in the GLM-5 docs and use the documented model name.

Your first request with cURL

Create a minimal smoke test before integrating an SDK:

curl "https://api.z.ai/api/paas/v4/chat/completions" \
  -H "Authorization: Bearer $GLM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.3",
    "messages": [
      {
        "role": "system",
        "content": "You are a code reviewer. Flag issues as blocking or non-blocking."
      },
      {
        "role": "user",
        "content": "Review this shell script for safety:\n\nrm -rf $BUILD_DIR/*\ncp dist/* $DEPLOY_TARGET"
      }
    ],
    "temperature": 0.3,
    "max_tokens": 1024
  }'

Read the generated content from:

choices[0].message.content

Track token usage from:

usage.prompt_tokens
usage.completion_tokens

For multi-step coding or agent tasks, enable the documented reasoning mode:

"thinking": {
  "type": "enabled"
}

Use thinking for tasks that benefit from planning or deeper analysis. Skip it for simple classification, extraction, or short transformations where extra reasoning is unnecessary.

Python quickstart

Install the OpenAI SDK:

pip install --upgrade openai

Then point the client at Z.ai:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["GLM_API_KEY"],
    base_url="https://api.z.ai/api/paas/v4",
)

response = client.chat.completions.create(
    model=os.environ.get("GLM_MODEL", "glm-5.3"),
    messages=[
        {
            "role": "system",
            "content": "You are a code reviewer. Flag issues as blocking or non-blocking.",
        },
        {
            "role": "user",
            "content": (
                "Review this Flask route for security issues:\n\n"
                "@app.route('/user/<id>')\n"
                "def get_user(id):\n"
                "    return db.execute(f'SELECT * FROM users WHERE id = {id}')"
            ),
        },
    ],
    temperature=0.3,
    max_tokens=2048,
)

print(response.choices[0].message.content)
print("input tokens:", response.usage.prompt_tokens)
print("output tokens:", response.usage.completion_tokens)

Log usage from the first day of testing. Until GLM-5.3-specific pricing is published, token counts are your best input for cost projections.

Node.js quickstart

Install the SDK:

npm install openai

Create a client with the Z.ai base URL:

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.GLM_API_KEY,
  baseURL: "https://api.z.ai/api/paas/v4",
});

const response = await client.chat.completions.create({
  model: process.env.GLM_MODEL || "glm-5.3",
  messages: [
    {
      role: "system",
      content:
        "You are a terminal automation agent. Return each step as a shell command with a one-line rationale.",
    },
    {
      role: "user",
      content:
        "A Node service on port 3000 stopped responding after a deploy. Give me a diagnosis sequence.",
    },
  ],
  temperature: 0.3,
  max_tokens: 2048,
});

console.log(response.choices[0].message.content);
console.log("usage:", response.usage);

If your application already uses OpenAI, create a second OpenAI client with the Z.ai baseURL. This makes model comparisons a routing decision instead of an integration rewrite.

Stream responses

Set stream=True in Python:

stream = client.chat.completions.create(
    model=os.environ.get("GLM_MODEL", "glm-5.3"),
    messages=[
        {
            "role": "user",
            "content": "Explain the N+1 query problem with a concrete ORM example.",
        }
    ],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

For raw HTTP requests, send:

"stream": true

Then parse server-sent event (SSE) data: lines using the OpenAI chunk format.

Two implementation details matter:

Token usage is available at or after the final chunk, so finalize accounting only after the stream closes.
With thinking enabled, hard prompts may have a longer time-to-first-token because the model reasons before emitting visible output.

Parameters that matter

Parameter	Type	What it does
`max_tokens`	integer	Caps output length. This is a primary cost control.
`temperature`	number	Use `0.2`–`0.4` for code and extraction; use `0.7+` for more open-ended writing.
`thinking`	object	`{"type": "enabled"}` enables reasoning mode for multi-step tasks.
`stream`	boolean	Returns server-sent events instead of a single response.
`messages`	array	Standard OpenAI-compatible `system`, `user`, and `assistant` messages.

Zhipu had not published GLM-5.3-specific API pricing at launch. Check the official pricing page instead of relying on reseller estimates.

At the time of writing, the page listed:

Model	Input price per 1M tokens	Output price per 1M tokens
GLM-5.2	$1.40	$4.40
GLM-5	$1.00	$3.20

For repeated instructions, keep stable system prompts consistent so eligible requests can benefit from cached-input discounts. The cost-control patterns in this DeepSeek API price increase postmortem apply here as well.

Test GLM-5.3 in Apidog before writing application code

Use Apidog to validate request shape, compare models, and save fixtures before putting prompts into your application.

1. Create the chat completions request

Create:

POST /chat/completions

Use the OpenAI-compatible request body:

{
  "model": "{{GLM_MODEL}}",
  "messages": [
    {
      "role": "user",
      "content": "Explain this error message."
    }
  ],
  "temperature": 0.3,
  "max_tokens": 1024
}

2. Create regional environments

Create two environments:

zai-international
bigmodel-mainland

Set these variables:

Variable	`zai-international`	`bigmodel-mainland`
`BASE_URL`	`https://api.z.ai/api/paas/v4`	`https://open.bigmodel.cn/api/paas/v4`
`GLM_API_KEY`	Your international key	Your mainland China key
`GLM_MODEL`	`glm-5.3`	`glm-5.3`

Set the request URL to:

{{BASE_URL}}/chat/completions

Set the authorization header at the environment level:

Authorization: Bearer {{GLM_API_KEY}}

This prevents keys from being copied into saved requests and lets you switch regions without editing the endpoint.

3. Test reasoning mode side by side

Duplicate a request.

In one request, add:

"thinking": {
  "type": "enabled"
}

Compare the same prompt across both requests:

time to first token
final latency
response quality
token usage

Use the result to decide which workloads justify reasoning mode.

4. Save successful responses as examples

Save good outputs as examples or fixtures. Reuse them for request-shape and schema validation without calling the live API repeatedly.

Then build regression scenarios that assert:

HTTP status
finish_reason
response schema
expected response content patterns
token usage thresholds

For a broader workflow, see the API testing guide for QA engineers.

Error handling and rate limits

Expect OpenAI-style errors with an error object containing fields such as message, type, and code.

Common status codes:

Status	Typical cause	What to do
`400`	Invalid request body or unknown model	Validate JSON and confirm the model ID.
`401`	Missing, invalid, or revoked key	Check `GLM_API_KEY` and authorization headers.
`429`	Rate limit reached	Retry with exponential backoff and jitter.
`5xx`	Transient provider failure	Retry with bounded backoff and log request IDs if available.

Implement retries for 429 and 5xx errors. For example, in Python:

import random
import time
from openai import APIStatusError

def create_completion_with_retry(**kwargs):
    for attempt in range(5):
        try:
            return client.chat.completions.create(**kwargs)
        except APIStatusError as error:
            retryable = error.status_code == 429 or error.status_code >= 500

            if not retryable or attempt == 4:
                raise

            delay = min(2 ** attempt, 16) + random.uniform(0, 0.5)
            time.sleep(delay)

Avoid hardcoding rate-limit assumptions. Check Z.ai’s official docs for current concurrency and tier limits.

Keep the model ID in configuration so you can roll back to glm-5.2 or another documented family model without redeploying code. The debugging workflow used for Grok’s API transfers directly because both APIs use the OpenAI-style format.

FAQ

What is the GLM-5.3 API model ID?

The expected model ID is glm-5.3, following the glm-5.2 and glm-5.1 naming pattern. However, the launch-day GLM-5 documentation listed glm-5, so confirm the currently supported ID before pinning it in production.

Does GLM-5.3 work with the OpenAI SDK?

Yes. Use the official openai packages for Python or Node.js, set the base URL to:

https://api.z.ai/api/paas/v4

For mainland China, use:

https://open.bigmodel.cn/api/paas/v4

The request and response shapes follow the chat completions standard, including streaming.

How much does GLM-5.3 cost?

Zhipu had not published GLM-5.3-specific pricing at launch. Use the official pricing page for current numbers. GLM-5.2 was listed at $1.40 per 1M input tokens and $4.40 per 1M output tokens.

How does GLM-5.3 compare with Claude and GPT?

Zhipu’s evaluations describe GLM-5.3 coding and agent capability as “approaching Claude Fable 5.” It reported CyberGym at 84.5% and ExploitBench at 54.4%. These are vendor-reported results, so validate performance using your own workload and prompt suite. For a broader comparison, see Grok 4.6 vs GPT-5.6 vs Claude Fable 5.

Can I run GLM-5.3 locally?

Not yet. Zhipu says open weights should arrive around August 28, 2026, through its Hugging Face organization. The GLM-5 family’s 744B-parameter MoE architecture is server-class infrastructure, not a typical laptop deployment.

Where GLM-5.3 fits in your stack

GLM-5.3 is worth evaluating for agent loops, code review, terminal automation, and multi-step coding tasks. The OpenAI-compatible API means the evaluation is low-effort:

Create an API key.
Run the cURL smoke test.
Put the endpoint, API key, and model ID behind environment variables.
Test thinking enabled and disabled with your production-like prompts.
Save outputs as regression fixtures.
Port the approved request into Python or Node.js.

Download Apidog to create separate regional environments, compare model configurations, inspect token usage, and turn working prompts into reusable API tests.

What Is GLM-5.3? Zhipu's Open-Weight Coding Model Explained

Hassann — Sun, 16 Aug 2026 15:29:50 +0000

GLM-5.3 is a large language model released on August 14, 2026 by Zhipu AI, the Chinese lab that operates internationally as Z.ai. It is a post-training upgrade of the GLM-5 base model focused on coding and agentic workloads. Zhipu plans to publish open weights on Hugging Face about two weeks after launch and reports a 50% coding-capability improvement over GLM-5.2 in its internal evaluations.

Try Apidog today

The release matters because Zhipu—a lab that Seeking Alpha describes as a “Chinese OpenAI challenger”—is shipping a coding-focused model it says is “approaching Claude Fable 5,” then making the weights available. It arrived one day after DeepSeek’s latest release, covered in our DeepSeek V4 Pro API guide.

This guide covers the model’s reported benchmarks, the open-weights plan, and how to send a first API request. You can test the request in Apidog without writing application code.

TL;DR

GLM-5.3 shipped on August 14, 2026 from Zhipu AI (Z.ai). It uses the same GLM-5 base model; reported gains come from scaled post-training.
Terminal-Bench 3.0 increased from 4.6 to 28.3: a 6.2x improvement and first place among open-source models, according to launch reporting.
It also ranks first among open models on Agents’ Last Exam.
CyberGym: 84.5%, slightly above Claude Mythos 5 and GPT-5.6 Sol in the reported results. ExploitBench: 54.4%, still behind frontier models.
Open weights are expected on Hugging Face around August 28, 2026.
Official GLM-5 family specs: Mixture of Experts, 744B total parameters, roughly 40B active per forward pass, and a 200K-token context window.
The API is OpenAI-compatible at https://api.z.ai/api/paas/v4/chat/completions.
No GLM-5.3-specific pricing was published at launch.

What GLM-5.3 is

GLM-5.3 is the third point release in the GLM-5 family and its most coding-focused release. Zhipu did not retrain the foundation model. The official docs describe GLM-5 as a Mixture of Experts model with:

744B total parameters
~40B active parameters per forward pass
200K-token context window

Those base specifications carry over unchanged. Zhipu attributes the improvements to scaled post-training rather than changes to the foundation weights.

That distinction is important when evaluating the model. The reported gains target terminal-driven agent tasks, long-horizon software engineering, and security analysis—not general chat performance.

For implementation teams, GLM-5.3 is worth evaluating when you need autonomous coding behavior, terminal-tool workflows, or a future self-hosting path once the open weights are available.

GLM-5.3 benchmarks: results and sources

Launch coverage from BigGo Finance and Pandaily reported the following results.

Benchmark	GLM-5.3 result	Context	Source
Terminal-Bench 3.0	28.3, up from 4.6	6.2x increase; first among open-source models	Launch report
Agents’ Last Exam	First among open-source models	Score not disclosed at launch	Launch report
CyberGym	84.5%	Slightly above Claude Mythos 5 and GPT-5.6 Sol	Launch report
ExploitBench	54.4%	Trails frontier models	Launch report
SWE-Marathon	Roughly 2x GLM-5.2	Long-horizon software engineering	Zhipu internal
Coding capability aggregate	+50% vs. GLM-5.2	Zhipu’s headline claim	Zhipu internal

Treat the source column as part of the result.

A Terminal-Bench 3.0 increase from 4.6 to 28.3 is substantial. Terminal benchmarks test whether a model can chain shell commands, inspect command output, and recover from errors across multiple steps. If those reported results hold in independent testing, GLM-5.3 becomes a stronger candidate for coding-agent pipelines than GLM-5.2.

However, the most frequently quoted claims—the 50% coding gain and roughly doubled SWE-Marathon score—come from Zhipu’s internal evaluations. They are useful evaluation signals, but they are not independently reproducible until the weights are released and external evaluators rerun the suites.

What “approaching Claude Fable 5” means in practice

Zhipu describes GLM-5.3’s coding and agent capability as “approaching Claude Fable 5.” The wording matters.

The reported agent and terminal results are close to frontier territory:

First among open-source models on Terminal-Bench 3.0
First among open-source models on Agents’ Last Exam
84.5% on CyberGym, slightly above Claude Mythos 5 and GPT-5.6 Sol in the launch report

But the model does not match frontier systems across every benchmark. On ExploitBench, GLM-5.3 scored 54.4% and remained behind frontier models. Exploit development requires deep, multi-step reasoning under ambiguity, and that result suggests closed frontier models still lead on the hardest reasoning-heavy work.

For your stack, use GLM-5.3 as an evaluation candidate for:

Terminal agents
CI automation
Repository-scale coding tasks
Tool-using development assistants

For difficult reasoning workloads, keep frontier closed models in your comparison set. The Grok 4.6 vs GPT-5.6 vs Claude Fable 5 comparison covers similar benchmark categories with worked examples.

The open-weights plan: around August 28 on Hugging Face

Zhipu committed to publishing GLM-5.3 open weights about two weeks after launch, placing the expected release around August 28, 2026. Watch the zai-org Hugging Face organization, where the company hosts previous open releases.

The gap between hosted API availability and weight release is intentional. Zhipu says it built its most extensive risk review system to date for this release. That matters because a model with meaningful offensive-security capability presents a different risk profile when released as downloadable weights than when served through a monitored API.

Plan for self-hosting

A 744B-parameter MoE model is still server-class hardware territory, even when roughly 40B parameters are active per token. Most teams should expect to evaluate:

The hosted API first.
Quantized community variants after the weights release.
A local serving stack only after establishing an API baseline.

For sizing, serving options, and a hosted-vs-local test plan, see the GLM-5.3 self-hosting guide.

How GLM-5.3 fits the open-model landscape

The most obvious comparison is DeepSeek. Both labs release open weights, price aggressively, and shipped major releases within 24 hours of each other. The difference is focus:

DeepSeek V4 Pro: generalist flagship positioning
GLM-5.3: specialist positioning for coding agents

If most of your workload is agentic coding, GLM-5.3’s specialization is a reason to benchmark it first.

Cost is another factor. DeepSeek’s recent price increase, analyzed in the DeepSeek API cost optimization guide, shows how quickly open-model API pricing can change. Open weights provide a self-hosting hedge for teams that need more control over cost or deployment.

Zhipu had not published GLM-5.3-specific API pricing at launch. The official pricing page listed GLM-5.2 at:

$1.4 per 1M input tokens
$4.4 per 1M output tokens

Use those figures only as a reference point. Check the live pricing page before making budget commitments.

Once quantized variants are available, GLM-5.3 joins the models you can run without API dependency. See the roundup of the best local LLMs in 2026 for the current open-model landscape.

GLM Coding Plan quotas were reset

Zhipu reset GLM Coding Plan quotas for all users on August 14. If you subscribe through Z.ai, your allowance restarted on release day.

The Coding Plan is Zhipu’s flat-rate offering for coding tools. It is separate from pay-per-token API billing, so the reset does not change API charges.

Mainland China users access the same ecosystem through open.bigmodel.cn, which has separate plans and billing.

Try the API in five minutes

Z.ai’s API is OpenAI-compatible. The international endpoint is:

https://api.z.ai/api/paas/v4/chat/completions

The mainland China endpoint is:

https://open.bigmodel.cn/api/paas/v4/chat/completions

Authentication uses a Bearer token.

At launch, the official docs still listed glm-5 as the documented model ID. The example below uses glm-5.3 based on the GLM-5 family naming convention. Confirm the current model ID in the model documentation before deploying.

export GLM_API_KEY="your-key-from-z.ai"

curl https://api.z.ai/api/paas/v4/chat/completions \
  -H "Authorization: Bearer $GLM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.3",
    "messages": [
      {
        "role": "user",
        "content": "Write a bash script that finds the five largest files in a git repo, excluding the .git directory."
      }
    ],
    "temperature": 0.6,
    "max_tokens": 1024
  }'

The response follows the OpenAI-style schema:

choices contains generated message content.
usage contains token counts.

Make the request reusable in Apidog

Instead of repeatedly editing cURL commands:

Import the request into Apidog.
Store GLM_API_KEY as an environment variable.
Create a z-ai environment using https://api.z.ai.
Create a bigmodel-cn environment using https://open.bigmodel.cn.
Store successful responses as regression baselines.
Switch environments and model IDs from the UI instead of modifying request text.

This gives you a repeatable test setup for comparing the hosted API against a local deployment after the weights are released.

For Python and Node.js clients, streaming, and error handling, see the full GLM-5.3 API quickstart.

FAQ

Is GLM-5.3 open source?

Not yet. Zhipu committed to releasing open weights on Hugging Face around August 28, 2026, roughly two weeks after API launch. Until then, access is through the hosted API.

How is GLM-5.3 different from GLM-5.2?

The base model is identical. Zhipu attributes the improvements to scaled post-training and reports:

50% coding capability improvement in internal evaluations
Terminal-Bench 3.0 increase from 4.6 to 28.3
Roughly doubled SWE-Marathon score

The GLM-5 family architecture, context window, and parameter count remain unchanged.

What does GLM-5.3 cost?

Zhipu had not published GLM-5.3-specific API pricing at launch. GLM-5.2 was listed at $1.4 per 1M input tokens and $4.4 per 1M output tokens on the official pricing page.

Check current pricing before budgeting. For general per-token cost controls, see API cost optimization after the DeepSeek price increase.

Can I run GLM-5.3 on my own hardware?

After the weight release, yes—with caveats. The GLM-5 family has 744B total parameters and approximately 40B active parameters per forward pass. Full-precision serving requires multi-GPU server hardware.

Quantized community builds should lower the hardware requirement. Review the self-hosting preparation guide before planning a deployment.

Is GLM-5.3 better than Claude or GPT for coding?

It depends on your workload.

The reported results show strong performance on agent and terminal benchmarks, including first place among open models on Terminal-Bench 3.0. It also reportedly edged Claude Mythos 5 and GPT-5.6 Sol on CyberGym.

However, GLM-5.3 trails frontier models on ExploitBench at 54.4%. Run your own workload-specific evaluation before moving production traffic, just as you would test any API before adopting it.

Where GLM-5.3 fits in your stack

GLM-5.3 is a specialist release with a clear implementation path:

Test the OpenAI-compatible hosted API now.
Save representative outputs from your real workloads.
Build a small regression suite for coding and agent tasks.
Re-run the suite when open weights and quantized variants become available.
Compare hosted API results against your own deployment before migrating traffic.

The reported benchmark story is strong for terminal and agent tasks, acknowledges an ExploitBench gap, and still needs independent verification after the weights release. That is enough evidence to justify evaluation, but not enough to justify an automatic production migration.

Use Apidog to organize your evaluation suite, keep Z.ai and bigmodel.cn as switchable environments, and turn exploratory calls into a regression baseline for comparing the hosted API with future self-hosted deployments.

Gemini 3.7 Flash Pricing Explained: Lock In Rates Before They Double

Hassann — Fri, 14 Aug 2026 07:54:21 +0000

Google shipped Gemini 3.7 Flash on August 13, 2026, three weeks after 3.6 Flash, and describes it as “our most intelligent workhorse model”. The implementation detail that matters most for production teams is pricing: the introductory rate of $0.75 per million input tokens and $3.75 per million output tokens ends on December 31, 2026. On January 1, 2027, both rates double.

Try Apidog today

That is a scheduled 2x increase for every Gemini 3.7 Flash workload. For example, a chatbot costing roughly $790/month at introductory pricing becomes about $1,575/month at standard pricing—even if your code, traffic, and prompts do not change.

This guide shows how to calculate both pricing tiers, estimate three common workloads, and add token-cost checks to your API workflow. If you have not sent a request yet, start with the Gemini 3.7 Flash API quickstart. Once requests are running, Apidog exposes usageMetadata token counts in responses so you can validate estimates against actual traffic.

TL;DR

Introductory pricing through December 31, 2026: $0.75 per 1M input tokens and $3.75 per 1M output tokens.
Standard pricing from January 1, 2027: $1.50 input and $7.50 output per 1M tokens.
Gemini 3.7 Flash's introductory price is half of Gemini 3.6 Flash's launch price.
The model supports text, image, video, audio, and PDF input, with a 1M-token context window and a 64k-token output limit.
A chatbot handling 10,000 requests/day costs about $26.25/day at introductory rates and $52.50/day at standard rates.
The biggest cost controls are output caps, context caching, batching, and routing simpler requests to a smaller model.

The two price tiers

Gemini 3.7 Flash launched with a temporary discount. For Gemini API usage billed through an AI Studio key, budget for both tiers:

Tier	Window	Input (per 1M tokens)	Output (per 1M tokens)
Introductory	August 13, 2026 to December 31, 2026	$0.75	$3.75
Standard	From January 1, 2027	$1.50	$7.50

Two practical implications follow:

The introductory rate is half of Gemini 3.6 Flash's launch price. If you are considering an upgrade, use the 3.6 to 3.7 Flash migration guide to plan regression tests and compare behavior.
Output tokens cost 5x more than input tokens in both tiers. Reducing output length usually delivers a larger saving than trimming a static prompt.

The prices above are Gemini API rates through AI Studio. Vertex AI uses Google Cloud billing and separate SKUs. Context caching and batch processing can also have separate line items. Verify current pricing on the official Gemini API pricing page before committing to a production budget.

Calculate cost from token usage

Use this formula for each endpoint:

cost =
  (input_tokens / 1_000_000 * input_rate) +
  (output_tokens / 1_000_000 * output_rate)

For the introductory tier:

cost =
  (input_tokens / 1_000_000 * 0.75) +
  (output_tokens / 1_000_000 * 3.75)

For the standard tier:

cost =
  (input_tokens / 1_000_000 * 1.50) +
  (output_tokens / 1_000_000 * 7.50)

Always calculate both. The standard-tier value is exactly 2x the introductory-tier value.

What real workloads cost

Workload 1: customer support chatbot

Assume:

10,000 requests/day
2,000 input tokens/request
300 output tokens/request

Line item	Daily tokens	Intro cost/day	Standard cost/day
Input	20M	$15.00	$30.00
Output	3M	$11.25	$22.50
Total	23M	$26.25	$52.50

Over 30 days, that is roughly:

$788/month at introductory rates
$1,575/month at standard rates

A practical implementation target is to cap support responses near the expected 300–500-token range rather than allowing unconstrained output.

Workload 2: PDF document pipeline

Gemini 3.7 Flash accepts PDFs natively. Its GDP.pdf benchmark score increased from 22.0% to 34.0% over 3.6 Flash, making document extraction a relevant workload.

Assume:

500 documents/day
40,000 input tokens/document
1,000 output tokens/document for a structured summary

Line item	Daily tokens	Intro cost/day	Standard cost/day
Input	20M	$15.00	$30.00
Output	0.5M	$1.88	$3.75
Total	20.5M	$16.88	$33.75

That is approximately:

$506/month at introductory rates
$1,013/month at standard rates

This workload is input-heavy. Focus on caching repeated instructions and using batch processing for non-interactive document jobs.

Workload 3: agent loop

Agents amplify token use because each step often includes growing conversation context and tool results.

Assume:

200 tasks/day
12 model calls/task
8,000 input tokens/call
400 output tokens/call

Line item	Daily tokens	Intro cost/day	Standard cost/day
Input	19.2M	$14.40	$28.80
Output	0.96M	$3.60	$7.20
Total	20.16M	$18.00	$36.00

That is:

$540/month at introductory rates
$1,080/month at standard rates

For agent workflows, track both call count and input size. Increasing a task from 12 calls to 20 calls raises cost by roughly 67% before accounting for any additional context growth.

The 64k output limit also bounds worst-case output cost per request at about:

$0.24 at introductory rates
$0.48 at standard rates

That is still expensive when retries repeatedly hit the maximum output size, so enforce endpoint-level limits.

How Gemini 3.7 Flash compares

Provider pricing changes frequently, so treat comparisons as market positioning rather than a permanent price sheet.

Gemini 3.7 Flash sits in the workhorse tier: cheaper than frontier offerings such as Gemini Pro, larger Claude models, or OpenAI's flagship tier, while posting benchmark results that overlap with models previously considered flagship-class. Google reports 65.3% on DeepSWE v1.1 and a 1588 WebDev Arena Elo.

The introductory rate is an opportunity to test whether the model is sufficient for your production routes before standard pricing starts. Do not assume a model's price will remain fixed: DeepSeek's API price increase and cost optimization guide shows why token budgets should include room for pricing changes.

For a small prototype, doubling may be irrelevant: $3 becomes $6. For a sustained $10,000/month pipeline, the same scheduled change becomes $20,000/month.

Five ways to cut token spend

1. Cap output tokens per endpoint

Set maxOutputTokens in generationConfig to the smallest value that satisfies the endpoint's contract.

{
  "generationConfig": {
    "maxOutputTokens": 500
  }
}

For example:

Support replies: 300–500 tokens
Classification: 20–100 tokens
Structured extraction: size according to the schema
Agent planning: a deliberately bounded limit per step

Output is 5x the cost of input, so this is usually the highest-return optimization.

2. Cache static context

Do not repeatedly pay full input pricing for unchanged system prompts, policies, reference documents, or large tool instructions.

If every request includes a static 3,000-token policy document, context caching can reduce the cost of repeatedly supplying it. Check the Gemini API documentation for current caching setup and pricing.

For the chatbot example, caching a 1,500-token static prefix can remove much of that repeated input cost.

3. Batch non-interactive work

Document ingestion, summarization, extraction, and overnight report generation often do not require immediate responses.

Use batch processing where latency is acceptable. This is especially useful for large PDF pipelines, where input volume dominates the bill.

4. Route requests to the smallest capable model

Use Gemini 3.7 Flash for work that needs multi-step planning, debugging, or tool-call chains. Route simpler operations—such as classification, routing, and short extraction—to a Flash-Lite tier model when quality testing supports it.

A simple routing strategy can look like this:

function selectModel(task: "classify" | "extract" | "agent" | "debug") {
  if (task === "classify" || task === "extract") {
    return "flash-lite";
  }

  return "gemini-3.7-flash";
}

Validate quality per route before changing production traffic.

5. Prototype on the free tier

Use AI Studio's free quota to finalize prompts, schemas, and output limits before sending billed production traffic. The free Gemini API access guide explains the available free path and its limitations.

Track spend per endpoint with Apidog

Estimates are useful for planning; per-request measurements are what keep a service inside budget.

Gemini responses include usageMetadata, including prompt and output token counts. Capture these values in your API tests and treat token growth as a regression.

A typical Gemini response exposes values similar to:

{
  "usageMetadata": {
    "promptTokenCount": 2148,
    "candidatesTokenCount": 312,
    "totalTokenCount": 2460
  }
}

In Apidog, set up cost checks per endpoint:

Create one request for each production route: chat turn, document summary, agent step, and so on.
Store the API key in an environment variable such as GEMINI_API_KEY.
Send realistic payloads, not placeholder prompts.
Extract usageMetadata.promptTokenCount and usageMetadata.candidatesTokenCount.
Add token-budget assertions.
Run the scenario whenever prompts, schemas, retrieval context, or tool outputs change.

For example, enforce an input-token budget for a chat endpoint:

const inputTokens = response.body.usageMetadata.promptTokenCount;
const outputTokens = response.body.usageMetadata.candidatesTokenCount;

pm.test("Chat prompt stays within token budget", () => {
  pm.expect(inputTokens).to.be.below(2500);
});

pm.test("Chat output stays within token budget", () => {
  pm.expect(outputTokens).to.be.below(500);
});

If a prompt edit pushes input from 2,000 to 2,500 tokens, your test can fail before deployment instead of silently increasing cost by 25%.

To calculate the measured request cost:

const inputTokens = response.body.usageMetadata.promptTokenCount;
const outputTokens = response.body.usageMetadata.candidatesTokenCount;

const introCost =
  (inputTokens / 1_000_000) * 0.75 +
  (outputTokens / 1_000_000) * 3.75;

const standardCost =
  (inputTokens / 1_000_000) * 1.5 +
  (outputTokens / 1_000_000) * 7.5;

console.log({ introCost, standardCost });

Token counts can regress just like latency or error rate. The difference is that token regressions show up later as an invoice. For a broader test-suite structure, see the API testing guide for QA engineers.

FAQ

When does Gemini 3.7 Flash pricing double?

On January 1, 2027. The introductory rate of $0.75 per 1M input tokens and $3.75 per 1M output tokens runs through December 31, 2026. It then changes to $1.50 input and $7.50 output per 1M tokens.

Is Gemini 3.7 Flash cheaper than Gemini 3.6 Flash?

At launch, yes. Gemini 3.7 Flash's introductory price is half of Gemini 3.6 Flash's launch price, while reported benchmarks improved, including DeepSWE v1.1 from 49.0% to 65.3%. See the Gemini 3.7 Flash quick reference for the full comparison.

Does the introductory price apply on Vertex AI?

This guide covers Gemini API pricing billed through an AI Studio key. Vertex AI uses Google Cloud billing, separate SKUs, and enterprise terms. Confirm current Vertex pricing in your GCP billing console and on the official pricing page.

What counts toward input tokens?

Everything sent in the request counts: text, images, video, audio, and PDF content are converted to input tokens. For exact post-request counts, inspect the response's usageMetadata.

How do I estimate tokens before sending a request?

Use the API's countTokens endpoint for a preflight estimate, or send representative requests and inspect usageMetadata.

Measure real payloads, including system prompts, retrieved documents, tool definitions, and conversation history. Token behavior does not necessarily match tokenizers from other providers.

Where Gemini 3.7 Flash fits in your stack

The practical approach is straightforward:

Move appropriate workhorse traffic to Gemini 3.7 Flash during the introductory period.
Measure actual token use per endpoint.
Add token budgets to API tests.
Model the January 2027 standard-rate bill now.
Route lighter requests to cheaper models where quality allows.
Use caching, batching, and output caps before traffic scales.

Download Apidog to keep Gemini requests, environments, token assertions, and cost checks in one workspace—so January's invoice is a number you predicted rather than a surprise.

What's New in Gemini 3.7 Flash? Features, Benchmarks, and API Access

Hassann — Fri, 14 Aug 2026 07:53:24 +0000

Gemini 3.7 Flash is Google’s newest workhorse AI model, released on August 13, 2026, three weeks after Gemini 3.6 Flash. It keeps the 1M token context window and multimodal input of its predecessor while posting large gains on coding and agent benchmarks, and it launches at an introductory API price of $0.75 per 1M input tokens. Google calls it “our most intelligent workhorse model.”

Try Apidog today

That three-week gap between releases is the story. Google is shipping Flash updates on a sprint cadence while Gemini 3.5 Pro stays delayed, which means the mid-tier model is now where the interesting engineering lands first. The benchmark deltas back that up: DeepSWE jumps 16 points, AutomationBench nearly doubles, and the intro pricing undercuts the 3.6 Flash launch rate by half.

This post covers what changed, the benchmark results, the pricing windows to calendar, where to access the model, and a cURL request you can run in five minutes. For a deeper endpoint walkthrough, see the Gemini 3.7 Flash API quickstart. You can also use Apidog to test the new model against your current prompts before switching production traffic.

TL;DR

Gemini 3.7 Flash launched August 13, 2026, three weeks after 3.6 Flash. Model ID: gemini-3.7-flash.
Coding and agent benchmarks improved: DeepSWE v1.1 went from 49.0% to 65.3%, AutomationBench from 17.0% to 30.4%, and WebDev Arena from 1538 to 1588 Elo.
Intro API pricing is $0.75 per 1M input tokens and $3.75 per 1M output tokens—half of 3.6 Flash’s launch price. Standard rates ($1.50 / $7.50) start January 1, 2027.
Specs are unchanged: 1M-token input context, 64k output limit, multimodal input, function calling, search as a tool, and computer use.
It is available in the Gemini API, AI Studio, Gemini app, Gemini Spark, Google Antigravity, Android Studio, and Gemini Enterprise across 160+ countries.
Gemini 3.5 Pro is still delayed, while Google continues shipping Flash improvements.

What Gemini 3.7 Flash is

Flash is the middle tier of the Gemini line: cheaper and faster than Pro, smarter than Flash-Lite, and tuned for high-volume production workloads. Gemini 3.7 Flash is the third Flash release in the 3.x line.

The official announcement positions it as a coding and agent model first, and a chat model second.

The spec sheet carries over from 3.6 Flash:

Context: 1M-token input window and 64k-token output limit.
Input modalities: text, image, video, audio, and PDF. Output is text.
Tooling: function calling, search as a tool, and computer use.
Safety: updated CBRN and cyber safeguards ship with the release.

What changed is behavior rather than architecture. Google says 3.7 Flash debugs better, produces deployable code on the first try more often, adapts when it hits roadblocks, asks clarifying questions for ambiguous intent, and follows instructions more reliably.

The benchmarks are the part you can validate with your own prompt suite.

Benchmark improvements: 3.6 vs. 3.7

Google spread these results across a blog post and model card. Here are the key deltas:

Benchmark	Gemini 3.6 Flash	Gemini 3.7 Flash	Change
DeepSWE v1.1 (agentic coding)	49.0%	65.3%	+16.3 pts
FrontierCode 1.1 Main	34.4%	43.6%	+9.2 pts
WebDev Arena (Elo)	1538	1588	+50 Elo
GDP.pdf (document reasoning)	22.0%	34.0%	+12.0 pts
AutomationBench (agent tasks)	17.0%	30.4%	+13.4 pts

Two standalone scores add context:

90.7% on Harvey LAB-AA, a legal reasoning benchmark.
97.0% on 128k-needle long-context retrieval.

The largest gains are on multi-step agent tasks. AutomationBench moving from 17.0% to 30.4% may change which workflows are viable for a mid-tier model. Launch coverage highlighted the DeepSWE result for the same reason: a 16.3-point gain in agentic coding over three weeks is notable.

For cross-model benchmark context, see Grok 4.6 vs GPT 5.6 vs Claude Fable 5.

Coding and agent improvements

Use the benchmark changes to define a targeted evaluation instead of relying on generic chat prompts.

Test these areas:

Debugging: Give the model failing tests and multi-file repositories. DeepSWE is the closest benchmark signal because it measures multi-file bug fixes.
First-try deployable code: Ask for implementation changes with explicit acceptance criteria, then run the generated code. FrontierCode improved by 9.2 points.
Roadblock handling: Simulate failed tool calls, missing files, or permission errors. Check whether the model changes its plan instead of repeating the same failed step.
Intent clarification: Send ambiguous requirements. Measure whether it asks a useful question before making assumptions.
Instruction fidelity: Test output schemas, length limits, negative constraints, and formatting requirements across longer conversations.

The tool stack is also unchanged from 3.6 Flash:

Function calling for structured integrations.
Search as a tool for retrieval workflows.
Computer use for browser-driven tasks when an API does not exist.

Computer use can be useful, but it is slower and less deterministic than a structured API integration. See computer use vs. structured APIs to decide which approach fits a workflow.

Pricing: half price until December 31, 2026

Gemini 3.7 Flash has a two-phase Gemini API pricing schedule:

Period	Input per 1M tokens	Output per 1M tokens
Through December 31, 2026	$0.75	$3.75
From January 1, 2027	$1.50	$7.50

The introductory price is half of Gemini 3.6 Flash’s launch price. However, the cost doubles on January 1, 2027.

Before deploying:

Verify current pricing on the official Gemini API pricing page.
Forecast long-lived workloads using the standard 2027 rate.
Record input and output tokens for each request from API usage metadata.
Compare cost per successful task, not only cost per token.

For worked token-cost examples, see the Gemini 3.7 Flash pricing breakdown.

Where you can use it today

Google shipped 3.7 Flash across its product surface area in 160+ countries:

Gemini API: Get a key from AI Studio and call gemini-3.7-flash.
Google AI Studio: Browser playground for prompt testing.
Gemini app: Consumer chat app access.
Gemini Spark: Available to AI Pro and Ultra subscribers.
Google Antigravity: Google’s agentic development environment.
Android Studio: IDE code assistance.
Gemini Enterprise: Managed organizational offering.

For API access at scale, Vertex AI provides a path through aiplatform.googleapis.com with OAuth, IAM, and audit logging. The model and request schema are the same, but authentication and hosting guarantees differ.

Why Google shipped Flash before Gemini 3.5 Pro

The release order is unusual: 3.6 Flash arrived in late July, 3.7 Flash followed three weeks later, and Gemini 3.5 Pro still has no date.

Axios reports that Google is shipping Flash updates while its next flagship remains delayed. For developers, the practical takeaway is straightforward: do not treat Flash as the trailing edge of the model lineup. Agent capabilities are landing there first.

If you deferred a migration from 3.6 Flash while waiting for Pro, start with the 3.6 to 3.7 Flash migration guide. For most codebases, the migration is a model ID change followed by regression testing.

How to try the API in five minutes

Create an API key in AI Studio, export it, then send a request:

export GEMINI_API_KEY="AIza..."

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.7-flash:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{
      "parts": [{
        "text": "Review this function for bugs: def dedupe(items): return list(set(items))"
      }]
    }],
    "generationConfig": {
      "temperature": 0.4,
      "maxOutputTokens": 1024
    }
  }'

The response includes:

A candidates array containing generated content in content.parts.
A usageMetadata object with exact input and output token counts.

Capture usageMetadata from day one. It is your cost meter.

To stream output, replace :generateContent with :streamGenerateContent?alt=sse:

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.7-flash:streamGenerateContent?alt=sse" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{
      "parts": [{ "text": "Explain server-sent events in three bullet points." }]
    }]
  }'

Once the request works, move comparisons out of the terminal. In Apidog:

Import the Generative Language API specification.
Store GEMINI_API_KEY as an environment variable.
Bind it to the x-goog-api-key header.
Save the model ID as a path variable.
Run identical requests against gemini-3.6-flash and gemini-3.7-flash.
Save outputs as examples for regression testing.

This gives you a direct comparison of output quality, instruction following, streaming behavior, latency, and token usage using your own workload.

FAQ

Is Gemini 3.7 Flash free to use?

The Gemini API has a free tier through AI Studio with daily quota for prototyping. Paid usage starts at $0.75 per 1M input tokens through December 31, 2026.

For guidance on working within quota limits, see free Gemini API access.

What’s the difference between Gemini 3.6 Flash and 3.7 Flash?

The model specs are the same: context window, output limit, modalities, and tool support remain unchanged.

The differences are benchmark and behavior improvements:

DeepSWE: +16.3 points
AutomationBench: +13.4 points
WebDev Arena: +50 Elo

Google also claims improved debugging, instruction following, and multi-step planning.

Does Gemini 3.7 Flash replace Gemini 3.5 Pro?

No. Pro remains the flagship tier for the hardest reasoning tasks, and Gemini 3.5 Pro is still in development.

Gemini 3.7 Flash targets high-volume production workloads where cost and latency matter alongside quality.

What happens to pricing on January 1, 2027?

The introductory price ends. Standard pricing becomes:

Input: $1.50 per 1M tokens
Output: $7.50 per 1M tokens

Budget at the standard rate for workloads that will continue beyond 2026.

Can Gemini 3.7 Flash process images and PDFs?

Yes. It accepts text, image, video, audio, and PDF inputs in the same contents array. Output is text only.

Google’s GDP.pdf result increased from 22.0% to 34.0%, which it presents as evidence of improved document reasoning.

Where 3.7 Flash fits in your stack

Gemini 3.7 Flash combines agent-focused benchmark improvements with unchanged integration specs and a temporary pricing discount.

The implementation path is simple:

Run your existing prompt suite against gemini-3.7-flash.
Compare outputs with your current model.
Track token usage and latency.
Test structured output, tool failures, long-context retrieval, and ambiguous instructions.
Make the migration decision from measured results.

Use Apidog to save 3.6 Flash responses as examples, replay the same requests against 3.7 Flash, and validate whether the benchmark improvements hold for your workload.

DEV Community: Hassann

How to Use Claude for Free in 2026: Every Option That Works

Is Claude free?

Option 1: Use the claude.ai free plan

Stretch your free quota

Option 2: Get Claude Code through guest passes

Option 3: Use free API credits with Apidog

Option 4: Access Claude through tools you already use

Option 5: Use cloud-provider trial credits

What free Claude does not include

FAQ

Start free, test smart

How to Use NotebookLM in 2026: A Practical Guide to Google's Free Research Tool

NotebookLM in 2026: A Practical Guide for Research and API Documentation

What is NotebookLM, and is it free?

Set up your first notebook

Add sources: supported formats and limits

Supported sources

Limits and common problems

Features worth using

Audio Overviews

Video Overviews

Mind maps

Reports, flashcards, and quizzes

Free vs. paid NotebookLM tiers

Developer workflow: use NotebookLM for API documentation

Build an API documentation notebook

Know what NotebookLM cannot do

FAQ

Does NotebookLM train on my uploaded data?

Can I share a notebook?

Is there a NotebookLM API?

Which languages does NotebookLM support?

Conclusion

Is DeepSeek Free? Chat, API Pricing, and Every Free Path in 2026

Is DeepSeek Free? Chat, API, and Local Hosting Costs Explained

Is DeepSeek free?

Free chat app: what you get and its limits

DeepSeek API pricing

Free and near-free API options

Run DeepSeek locally for free

Chat vs. API vs. local hosting

Test one real call, mock the rest

FAQ

Bottom line

How to Run Any Model in DeepSeek Harness ?

Why change models in an agent harness?

Cost

Data locality

Local development

Configure a provider block

Provider fields

Store API keys safely

Recipe 1: Run a local model with Ollama

Local setup checklist

Recipe 2: Use a hosted OpenAI-compatible endpoint with Qwen via DashScope

Hosted endpoint compatibility settings

Recipe 3: Use built-in catalog providers

Select a model and understand session behavior

Troubleshooting provider configuration

Wrong or unreachable baseURL

Missing or empty environment variable

Image input does not work

Unsupported roles or token fields

A previously working configuration stopped working

FAQ

Does DeepSeek Harness officially support Ollama?

Where does dsh store API keys?

Can different sessions use different models?

My endpoint works with curl but fails in dsh. What should I check?

How to Use the Apidog CLI in DeepSeek Harness

Which DeepSeek Harness this is about

Step 1: put the CLI in AGENTS.md

Step 2: get the command from Apidog

Step 3: have the agent run the test

Step 4: read the report

The loop, end to end

Verify dsh actually ran it

1. Confirm the command ran

2. Confirm the exit code

Wrong or unreachable `baseURL`

Step 1: put the CLI in `AGENTS.md`

2. Create `hosted` and `local` environments