DEV Community: Hassann

The Best SoapUI Alternative

Hassann — Tue, 04 Aug 2026 10:19:48 +0000

SoapUI has been testing web services since 2005, and for WSDL-driven SOAP work it is still the name everyone knows. But most teams looking for a SoapUI alternative in 2026 are testing REST, GraphQL, and gRPC APIs—not only SOAP—with a Java desktop app built around XML contracts, large XML project files, and Groovy for dynamic behavior.

Try Apidog today

Here is the practical answer: Apidog is a strong SoapUI alternative for API teams working with REST and modern protocols. It replaces much of the Groovy-based workflow with visual test orchestration, adds schema-aware mocking and published documentation, and offers a free plan for up to four users.

This guide explains where SoapUI shows its age, how to migrate a workflow, and when SoapUI is still the right choice.

Where SoapUI shows its age

SoapUI Open Source is maintained by SmartBear, and releases still happen; version 5.9 shipped in mid-2025. The main limitations are structural rather than maintenance-related:

It is designed around SOAP. SoapUI's core abstractions come from WSDL contracts: operations, envelopes, and XPath assertions. REST support was added later. Building and asserting JSON payloads can mean working against a UI designed for XML, a gap covered in SoapUI Pro vs SoapUI Open Source.
Dynamic behavior usually means Groovy. Request chaining, value extraction, conditions, and custom assertions commonly require Groovy. That is powerful for QA engineers who know the JVM, but it can make suites difficult for the rest of the team to maintain.
Projects are large XML files. A SoapUI project is typically one large XML document. When multiple people edit it, merge conflicts can be difficult to resolve. Teams often end up passing project files around instead of collaborating in a shared workspace.
The free tier is limited. Data-driven testing, native CI integrations, and detailed reporting are commercial features. SoapUI Pro was folded into ReadyAPI, and third-party trackers list ReadyAPI from around $829 per license per year. That upgrade point is often when teams evaluate alternatives, including these SoapUI alternatives.
It is a heavy desktop application. SoapUI is a Java Swing app that loads full projects into memory. Large suites can increase startup time and make the UI less responsive.

These trade-offs matter less if your work is primarily WSDL-driven SOAP. They matter much more when SOAP is a small part of a REST- and JSON-heavy API workload.

The answer: Apidog

Apidog is an API development platform used by over 500,000 developers. It brings API design, debugging, automated testing, mocking, and documentation into one workspace built around OpenAPI specifications rather than WSDL files.

For teams moving away from SoapUI, focus on these differences:

Build tests visually instead of writing every flow in Groovy.

Create scenarios that chain endpoints, pass values between requests, and assert on responses through the UI. The common SoapUI workflow—extract an ID, use it in a later request, then assert the result—becomes configuration-driven. Scripts are still available when needed, using Postman-compatible syntax instead of JVM-only Groovy.
Use the free plan for small teams.

The free plan covers up to four users with unlimited APIs, requests, and test runs. Features that SoapUI places in ReadyAPI, such as data-driven testing, CI integration, and shareable reports, are available in Apidog's core product.
Work with modern protocols natively.

REST, GraphQL, gRPC, WebSocket, and SSE are first-class workflows. JSON assertions operate on JSON responses rather than XML-oriented representations.
Avoid a four-figure per-seat upgrade path.

Paid plans start at $9 per user per month.

What changes in practice

Test logic without the Groovy tax

Apidog's test builder covers common scripted SoapUI patterns:

Extract a value from response A and reuse it in request B.
Run a scenario against each row in a CSV or JSON data set.
Branch based on a condition.
Assert status codes, schemas, headers, and response fields.

For example, a typical REST flow can be expressed as:

Send POST /users.
Extract $.id from the response.
Set userId as an environment or scenario variable.
Send GET /users/{{userId}}.
Assert that the response status is 200.
Assert that $.id matches {{userId}}.

This keeps the test readable for developers, QA engineers, and reviewers without requiring everyone to understand a Groovy codebase.

Mock from the schema instead of scripts

SoapUI mock services work well for SOAP, but REST mocks often require manually configured responses and additional Groovy. See SoapUI mock service: setup guide and modern alternative for a detailed comparison.

Apidog's smart mock engine reads an OpenAPI schema and returns realistic data automatically:

An email field can return an email-shaped value.
A price field can return a numeric value.
Defined examples and schemas can drive mock responses from the start.

That means frontend teams can begin integration work as soon as the API specification exists. A self-hosted mock option is also available when mock traffic must remain inside your network.

Run performance tests in the same workspace

SoapUI Open Source includes basic load testing, while more advanced capabilities are sold separately in ReadyAPI.

With Apidog, performance testing lives alongside functional tests:

Reuse an existing API scenario.
Configure concurrency and execution settings.
Run the test.
Review latency and throughput results.

This avoids exporting requests to a separate performance-testing tool just to test the same endpoints.

Add CI without wrestling with Java tooling

Apidog's CLI can run a scenario headlessly and generate an HTML report:

npm install -g apidog-cli
apidog run scenario --scenario-id 12345 --env staging

Use it in Jenkins, GitLab CI, or GitHub Actions. For the available commands, see how to manage APIs with Apidog CLI.

For example, a GitHub Actions step can run a scenario like this:

- name: Run API scenario
  run: |
    npm install -g apidog-cli
    apidog run scenario --scenario-id 12345 --env staging

Archive the generated HTML report as a build artifact so failures are visible from the CI run.

Generate documentation from the API contract

SoapUI produces test artifacts. Apidog can also generate the public-facing API documentation from the specification:

Interactive API documentation
Hosted documentation on a custom domain
A built-in “try it” console

For teams maintaining API docs separately from tests and specifications, this consolidates another workflow into the same workspace.

SoapUI vs Apidog at a glance

	SoapUI Open Source	Apidog
Price	Free; Pro features moved to ReadyAPI, ~$829+/license/year	Free for up to 4 users, then $9/user/month
Built for	SOAP/WSDL contracts	REST, GraphQL, gRPC, WebSocket
Test logic	Groovy scripts	Visual orchestration + optional scripts
Data-driven testing	Paid in ReadyAPI	Included on all plans
Mocking	SOAP-centric mock services	Schema-aware smart mocks, self-hostable
Load testing	Basic free option; full version paid	Included
CI integration	`testrunner` scripts	CLI with HTML reports
Docs generation	No	Yes, hosted with custom domain
Collaboration	Shared XML project files	Real-time team workspace
Platform	Java desktop	Desktop for Windows, macOS, and Linux, plus web app

The important caveat: if your workload is primarily SOAP and WSDL-driven, the advantages in the Apidog column matter less. SoapUI remains a specialist tool for that use case.

Migrating a SoapUI workflow

There is no one-click SoapUI project importer. Plan for re-creation rather than translation.

1. Start with the API contract

If your services already have OpenAPI definitions, import them directly into Apidog. Endpoints, schemas, and examples arrive as structured API definitions.

For older services without an OpenAPI specification, rebuild the request layer from:

A Postman collection
cURL commands
Existing request examples
Captured HTTP traffic

Start with one service rather than attempting a full platform migration immediately.

2. Rebuild test cases as scenarios

Choose a representative SoapUI test case and recreate it as a scenario.

A practical migration sequence is:

Recreate the first request.
Add the response assertion.
Extract values needed by follow-up requests.
Add the next request and inject extracted values.
Add error-path assertions.
Attach test data if the suite is data-driven.

This is re-creation, not a direct conversion. In practice, the new version is often smaller because XPath-heavy checks and Groovy property transfers become field-level assertions and visual steps.

3. Replace `testrunner` in CI

Update the CI job that currently calls testrunner.sh:

npm install -g apidog-cli
apidog run scenario --scenario-id 12345 --env staging

Then archive the generated HTML report in the same pipeline. Once all relevant suites have moved, the Java installation on build agents may no longer be required for those tests.

Budget a sprint for a mid-sized suite. The rewrite is also an opportunity to remove outdated test cases that have not been reviewed in years.

Your first hour after switching

Minutes 0–15: Import one service

Import an OpenAPI specification for one service. If you do not have one, use a Postman-format export or existing cURL commands.

Confirm that:

Endpoints are grouped correctly.
Request examples are available.
Environment variables are configured.
The API can be called from the selected environment.

Minutes 15–30: Rebuild one test case

Pick a SoapUI test case that uses a property transfer.

Recreate this flow:

Send request A.
Extract a field from the response.
Pass that field into request B.
Assert the status and response body from request B.

The goal is to verify that the test is understandable without Groovy.

Minutes 30–45: Make it data-driven

Attach a CSV or JSON data set and run the scenario once per input row.

For example:

email,password
dev1@example.com,secret-1
dev2@example.com,secret-2

Map each column to request variables, then run the scenario against every row.

Minutes 45–60: Put it in CI

Install the CLI, run the scenario by ID, and archive the HTML report:

npm install -g apidog-cli
apidog run scenario --scenario-id 12345 --env staging

At the end of the hour, you should know the answer to the key migration question: can the team build, run, and maintain the suite without relying on the one person who understands the existing Groovy and XML project structure?

When SoapUI still makes sense

SoapUI is still the better fit when your environment is dominated by WSDL-driven SOAP services, such as:

Banking middleware
Government integrations
Enterprise service buses
SOAP contracts that require generated envelopes and WSDL-aware workflows

Apidog can send XML request bodies over HTTP, so simple SOAP calls can work. However, it does not import WSDL files or generate SOAP envelopes from contract definitions.

If your team depends on deep JMS or JDBC virtualization, that is also ReadyAPI territory. See SmartBear pricing and top alternatives for a comparison of that stack.

Finally, if one QA engineer owns a mature Groovy suite that works reliably, rewriting it has a real cost. A switch is most compelling when REST and modern protocols make up most of your testing workload and the Groovy-and-XML overhead affects the entire team.

Frequently asked questions

Is Apidog free like SoapUI Open Source?

Apidog's free plan supports up to four users with unlimited APIs, requests, and test runs. It includes capabilities that SoapUI reserves for ReadyAPI, including data-driven testing, CI integration, and shareable test reports.

SoapUI Open Source is free for the core feature set on one machine at a time.

Can Apidog test SOAP services?

Apidog can send XML request bodies over HTTP, so simple SOAP calls work. It does not import WSDL files or generate SOAP envelopes from contract definitions.

If WSDL-driven testing is your daily work, keep SoapUI for that part of the workload.

Do I need to know Groovy to use Apidog?

No. Request chaining, value extraction, data-driven loops, and assertions can be configured visually.

Scripting is available when needed, using Postman-compatible syntax rather than Groovy.

What replaces SoapUI's `testrunner` in CI?

The Apidog CLI.

Install it with:

npm install -g apidog-cli

Then run scenarios by ID against the target environment and publish the generated HTML report as a build artifact:

apidog run scenario --scenario-id 12345 --env staging

This workflow fits Jenkins, GitLab CI, and GitHub Actions.

What happened to SoapUI Pro?

SmartBear merged SoapUI Pro into ReadyAPI, its commercial API testing platform. SoapUI Open Source continues, but advanced capabilities live in ReadyAPI. Third-party pricing trackers list ReadyAPI from around $829 per license per year.

Try it against one service

Pick one REST service currently tested in SoapUI. Import its OpenAPI specification, rebuild one test suite as an Apidog scenario, and connect that scenario to CI.

Download Apidog and time the exercise. The goal is not to migrate everything at once—it is to validate that your team can build and operate a readable, CI-connected API test scenario without relying on Groovy and shared XML project files.

The Best ReadMe Alternative

Hassann — Tue, 04 Aug 2026 07:14:15 +0000

ReadMe makes genuinely good-looking developer hubs, and its pricing reflects that confidence: the jump from the free Starter plan is $250 per month billed annually for Pro, while enterprise features such as SSO, audit logs, and removing ReadMe branding start at $3,000 per month, according to ReadMe’s pricing page. If you’re looking for a ReadMe alternative, it is usually because the invoice no longer matches the value—or because your documentation platform has no way to verify that your API actually works.

Try Apidog today

Here’s the direct answer: Apidog is a strong ReadMe alternative for API documentation because it generates docs from the same specification your team designs, tests, and mocks against. Docs stay current because they are a view of the working API, not a separate project. It is free for up to four users, with paid plans starting at $9 per user per month instead of a platform fee.

This guide covers where ReadMe’s model becomes expensive, what Apidog replaces, and where ReadMe still has an edge.

The two problems with docs-only platforms

The platform fee scales like a platform, not like docs

ReadMe’s Starter plan is free and useful: one project, a custom domain, and interactive API reference. The next tier is Pro at $250 per month billed annually. Enterprise starts at $3,000+ per month, where features such as SSO, user roles, audit logs, and removing the ReadMe logo are available.

AI features are also partly a separate cost: Ask AI is a $150-per-month add-on.

For a startup, $3,000 per month for documentation can represent a full engineer’s budget for a rendering layer. Teams have been doing this math for a while; this earlier roundup of ReadMe.io alternatives came from the same pressure.

The docs don’t know your API

The deeper issue is architectural, and it applies at any price.

ReadMe consumes your OpenAPI file; it does not produce or verify it. The spec is generated somewhere else, tested somewhere else, mocked somewhere else, and synced to ReadMe as a final step.

Every handoff creates an opportunity for drift:

API implementation
  -> OpenAPI spec generation
    -> testing
      -> mocking
        -> documentation sync

Bi-directional sync narrows the gap, but it does not close it. ReadMe cannot run your test suite, so bugs where “the docs say X, but the API does Y” can survive until a developer finds them in production.

That is the pattern with docs-first tools such as ReadMe, GitBook, and Document360. The rendering is often excellent, but the source of truth lives elsewhere. See the broader comparisons of GitBook alternatives and Document360 alternatives.

What the flat fee costs at team scale

Flat platform pricing and per-seat pricing cross at different points than many teams expect.

Here is the annual bill for a team that needs paid features on both sides, using ReadMe Pro at $250 per month billed annually against Apidog’s free-for-four plan and $9 per seat beyond that:

Team size	ReadMe Pro per year	Apidog per year	Difference
3 people	$3,000	$0 (free plan)	$3,000
5 people	$3,000	$540	$2,460
10 people	$3,000	$1,080	$1,920
25 people	$3,000	$2,700	$300

Two important caveats:

ReadMe’s flat fee can become cheaper on paper for very large teams. Past roughly 28 seats, Pro is nominally cheaper than Apidog’s per-seat cost.
At that size, teams often need SSO, roles, and unbranded docs, which moves ReadMe pricing to Enterprise at $36,000 per year or more.

If ReadMe’s free Starter tier genuinely covers your needs—one project and one version—the comparison is $0 versus $0. At that point, the decision comes down to workflow rather than price.

The answer: Apidog

Apidog is an API development platform used by over 500,000 developers. Documentation is one output of the platform, alongside API design, debugging, testing, and mocking, all driven by the same specification.

For a team comparing it with ReadMe, the practical differences are:

Docs come from the tested spec.

The endpoints your docs describe are the same endpoints your team debugs and runs automated tests against. Update the spec and the docs, mocks, and tests update together.
Publishing is included.

Publish interactive API reference documentation, a “try it” console that sends real requests, Markdown pages for guides, versioning, and a custom domain.
Pricing is per seat, not per platform.

Apidog is free for up to four users and starts at $9 per user per month beyond that. There is no $250-per-month jump between free and paid plans.
The consumer side is AI-ready.

Docs can publish alongside an MCP server, allowing AI agents to read your API specification directly instead of scraping HTML. See what Apidog MCP Server is.

What the switch looks like feature by feature

Interactive API reference

Both tools render OpenAPI into an API reference with a request console.

The difference is what powers the console. Apidog’s “try it” feature can run against real environments or the built-in smart mock server. The mock server generates realistic schema-based data as soon as the spec exists.

That means consumers can explore an API before it is deployed.

Guides and non-reference content

ReadMe’s guides, MDX components, and reusable content blocks are a genuine strength.

Apidog takes a more utilitarian approach: Markdown pages live alongside the API reference in the same documentation site. Use them for:

Onboarding guides
Authentication walkthroughs
Tutorials
Changelogs
Migration notes

If your docs are 80% narrative content with elaborate custom components, ReadMe’s editor may be a better fit. If your docs are 80% API reference with supporting pages, Markdown pages are typically enough.

Versioning and environments

Apidog versions documentation with the API itself. Environment definitions, including base URLs and authentication settings, flow into published documentation so consumers send requests to the right endpoints.

In ReadMe, versions are managed in the documentation platform, and unlimited versions require Pro.

The workflow upstream of the docs

This is the part ReadMe does not provide at any price.

Apidog puts the following workflow around the same API specification:

Spec editor
Request client
Automated test scenarios
Mock server
CI integration through Apidog CLI

A documentation page is backed by a specification that a test suite exercised that morning.

For teams currently paying for both ReadMe and Postman, consolidation can be a practical budget win: two subscriptions become one. The Stoplight comparison shows the same pattern from the API design-tool side.

ReadMe vs Apidog at a glance

	ReadMe	Apidog
Free plan	1 project, 1 version, custom domain	4 users, unlimited projects, docs included
First paid tier	$250/month billed annually (Pro)	$9 per user/month
SSO, roles, audit logs	Enterprise, $3,000+/month	Enterprise plan
Remove vendor branding	Enterprise only	Custom domain and layout on paid plans
AI assistant	Ask AI add-on, $150/month	AI features in platform
Spec editing	No, imports your spec	Yes, visual and code editors
API testing	No	Yes, visual scenarios and unlimited runs
Mock server	No	Yes, schema-aware smart mocks
Try-it console	Yes	Yes, against real or mock environments
Guides / MDX components	Strong, custom MDX on Pro	Markdown pages
API usage metrics in docs	Yes, developer dashboards	Request history in platform, not consumer-facing

The last two rows are ReadMe advantages.

The key decision is whether a richer narrative editor and consumer-facing usage dashboards justify a platform fee and a separate source of truth.

Migrating from ReadMe

The migration path is straightforward because the center of gravity is an OpenAPI file you already have.

Import your OpenAPI spec into Apidog.

Reference documentation is available immediately, with endpoints structured and grouped.
Move guide content.

Export ReadMe pages as Markdown and add them as Apidog documentation pages. Standard Markdown moves directly. Custom MDX components need to be rewritten as standard Markdown, which is the main manual step.
Point your custom domain to the Apidog-hosted docs.

Configure redirects for URLs that change during the move.
Add the workflow that did not exist in ReadMe.

Generate a mock server from the specification, build a smoke-test scenario, and run it in CI.

For example, a basic smoke test should verify that your published examples remain valid:

GET /health
Expected status: 200

GET /users/{id}
Expected status: 200
Expected response schema: User

A reference-heavy documentation site can typically move in a day or two. Content-heavy hubs take longer, depending on how much MDX customization they use.

When ReadMe still makes sense

ReadMe remains a sensible choice when your developer hub is primarily a content product:

Long-form guides and tutorials
Community forums
Marketing-grade landing pages
Dedicated documentation teams
Extensive custom MDX components

ReadMe Metrics is also differentiated if consumer-facing API usage dashboards matter—for example, when developers need to log in and view their own request logs directly in the docs.

Finally, if you are already on the free Starter tier with one project and it covers your needs, there is no urgency to switch.

The switch becomes more compelling when API reference is the core product, the platform fee is meaningful, and documentation drift is generating support tickets.

Frequently asked questions

Is Apidog really free for API documentation?

Yes. The free plan covers four users and includes publishing interactive docs with a try-it console.

ReadMe’s free Starter tier covers one project, while its paid tiers start at $250 per month billed annually.

Can Apidog docs live on my own domain?

Yes. Published docs support custom domains, custom layouts, and Markdown pages without a vendor-logo requirement tied to a $3,000 tier.

What happens to my ReadMe guides if I switch?

Export them as Markdown and add them as documentation pages in Apidog.

Standard Markdown moves as-is. Custom MDX components need to be converted to plain Markdown equivalents.

Does Apidog have something like ReadMe’s Ask AI?

Apidog publishes your spec through an MCP server, allowing AI assistants and agents to consume the API definition directly.

ReadMe’s Ask AI is a chat widget over documentation content, sold as a $150-per-month add-on.

How do the docs stay accurate in Apidog?

The docs are generated from the same specification your team tests against.

When automated scenarios run against an endpoint and its schema changes, the documentation regenerates from the same source. There is no separate sync step to forget.

Publish docs your API can’t drift from

Import your OpenAPI specification, publish the reference on your domain, and enable the mock server.

Download Apidog or start in the browser. A team of four pays nothing, and the docs you publish are backed by the specification your tests just verified.

For a feature-by-feature breakdown, see the Apidog vs ReadMe comparison page.

The Best SwaggerHub Alternative

Hassann — Tue, 04 Aug 2026 07:07:40 +0000

SwaggerHub built its reputation as a serious home for OpenAPI design. SmartBear has since folded it into the relaunched Swagger platform alongside Portal, Contract Testing, and Functional Testing modules. The packaging is where many teams start looking for alternatives: according to Swagger’s pricing page, plans range from $22.80 per user/month for Individual to $34.44 for Team and $58.80 for Enterprise. Testing is metered at 50–100 executions per month below the custom tier, SSO is a $6 per-user add-on, and API portals retain SmartBear branding below Enterprise Plus.

Try Apidog today

For teams that need spec-first API design without metered testing or layered add-ons, Apidog is a practical SwaggerHub alternative. It combines a visual OpenAPI designer, unlimited test runs, schema-aware mocking, and hosted documentation on your domain. It is free for up to four users, then $9 per user/month. This guide compares the current Swagger packaging, shows what changes in Apidog, and highlights cases where SwaggerHub is still the better fit.

What the new Swagger packaging actually costs

The relaunched platform includes Studio, Portal, Contract Testing, and Functional Testing in every plan. The limits and add-ons determine the effective price:

Per-seat pricing adds up. Swagger Team costs $34.44 per user/month, compared with Apidog’s $9 per paid seat. A 10-person Swagger Team workspace costs about $4,133 per year before add-ons. For a broader breakdown, see SmartBear pricing and top alternatives.
Test executions are metered. Individual and Team include 50 test executions per month; Enterprise includes 100. A CI pipeline that runs tests on every merge can consume that allowance quickly. Parallel test execution is available only on Enterprise Plus.
Portal branding is tiered. Depending on the plan, you can publish one to five products, but SmartBear branding remains. A custom domain and full white-labeling require Enterprise Plus.
Identity and advanced modules are add-ons. Enterprise SSO costs $6 per user/month on top of Team or Enterprise. Portal Pro ($29.40), Contract Testing Pro ($23), and Test Pro ($30) are additional per-user monthly add-ons.
API counts are capped. Individual supports 10 APIs and Team supports 50 APIs.

SwaggerHub’s design and governance tooling remains strong. The main consideration is that publishing, testing, and identity can each introduce separate costs around the OpenAPI specification.

The answer: Apidog

Apidog is an API development platform used by over 500,000 developers. Like SwaggerHub, it supports a spec-first workflow, but includes the rest of the API lifecycle without execution meters.

Four implementation differences stand out:

Run tests without execution limits. APIs, test runs, and scheduled executions are unlimited on every plan, including the free plan. You can run CI tests on every commit without tracking an execution quota.
Generate working artifacts from the spec. An OpenAPI definition can generate interactive documentation, a schema-aware mock server, and runnable test scenarios. Update the design, then propagate changes to those artifacts.
Publish docs on your own domain. Custom domains, layouts, and Markdown pages are standard publishing capabilities, without a vendor logo requirement.
Use simpler seat pricing. Apidog is free for up to four users and costs $9 per user/month after that. SSO, SCIM, and RBAC are available through the Enterprise plan rather than separate per-user add-ons.

Compare the seat math

At Swagger Team rates, the difference grows as the team expands.

Team size	Swagger Team per year	Apidog per year	Difference
4 people	$1,653	$0 (free plan)	$1,653
10 people	$4,133	$1,080	$3,053
20 people	$8,266	$2,160	$6,106

Adding Enterprise SSO at $6 per user/month increases a 20-person Swagger bill by another $1,440 per year. This comparison also assumes you do not exceed the 50-API Team cap or the 50-execution monthly limit.

Feature-by-feature: Swagger modules vs. Apidog

Studio → visual and code-based spec editing

Use Apidog’s visual designer or code editor to create and edit OpenAPI specifications. Teams can use branches to propose and review changes, while reusable schema components cover common SwaggerHub Domains use cases.

One important gap remains: Apidog does not provide organization-wide style-guide enforcement with custom linting rules. If your core requirement is Spectral-based governance across hundreds of specifications, SwaggerHub remains a strong option.

Portal → hosted API documentation

Apidog publishes interactive documentation with a try-it console connected to real environments or its built-in mock server.

A practical publishing workflow looks like this:

Import or create an OpenAPI definition.
Configure an environment or mock endpoint.
Publish interactive docs.
Map documentation to your custom domain.
Point consumers to the new URL.

SwaggerHub’s portal product limits and branding tiers do not have a direct equivalent in Apidog because documentation publishing is not positioned as an add-on.

Functional Testing → unlimited scenarios

This is the most significant operational difference. SwaggerHub meters included test executions; Apidog supports unlimited visual test scenarios, including chained steps, data extraction, assertions, and data-driven runs from CSV or JSON.

Run a scenario from CI with the Apidog CLI:

npm install -g apidog-cli
apidog run scenario --scenario-id 12345 --env staging

Each run generates an HTML report. You can schedule suites for deployments or run them on every merge without allocating an execution budget.

Automocking → schema-aware smart mocks

SwaggerHub automocking returns example-based responses and is unavailable on the Individual tier. Apidog’s smart mock engine reads schema field names and types to generate realistic values automatically:

email fields produce email-like values.
avatar_url fields produce URL-like values.
Custom expectations can return fixed responses where deterministic behavior is required.
A self-hosted option supports internal networks.

For a wider comparison of mock tooling, see best Swagger alternatives.

Beyond the modules

Apidog also works as a daily request client, so developers can debug requests in the same workspace where they design specifications, define tests, and publish docs.

It can also publish specifications through an MCP server for AI coding agents. See what is Apidog MCP Server.

SwaggerHub (Swagger) vs. Apidog at a glance

	Swagger / SwaggerHub	Apidog
Entry price	$22.80 per user/month (Individual)	Free up to 4 users
Team price	$34.44 per user/month + add-ons	$9 per user/month
APIs	10 (Individual) / 50 (Team)	Unlimited
Test executions	50–100 per month; unlimited only on Enterprise Plus	Unlimited on all plans
Parallel testing	Enterprise Plus only	Included
Mocking	Automocking, not on Individual	Schema-aware smart mocks, self-hostable
Portal branding	SmartBear branding below Enterprise Plus	Your domain and branding
SSO	$6 per user/month add-on	Enterprise plan
Spec governance / custom linting	Strong Spectral-based standardization	Basic validation; no organization-wide rulesets
Contract testing (Pact)	Yes, dedicated module	No
Gateway sync (AWS, Azure, Apigee)	Yes	No native gateway push
Request client for daily debugging	No	Yes

The trade-off is clear:

Choose SwaggerHub when large-scale governance, Pact contract testing, or gateway synchronization is central to your workflow.
Choose Apidog when your day-to-day work is designing, testing, documenting, mocking, and debugging APIs without execution limits or portal branding constraints.

Migrate from SwaggerHub to Apidog

Because both platforms support OpenAPI natively, migration is straightforward.

Export specifications from SwaggerHub. Export YAML or JSON. Endpoints, schemas, examples, and descriptions remain structured. Resolve shared Domain references into component schemas during export.
Import into Apidog. Import each OpenAPI file into an Apidog project or workspace.
Recreate the review workflow. Create branches for proposed changes and merge approved updates. The merged specification updates docs, mocks, and tests.
Publish new documentation. Configure your custom domain, update consumer links, and add redirects from the previous SwaggerHub portal.
Enable previously metered workflows. Schedule test scenarios on deployments and provide frontend teams with mock URLs.

A 50-spec workspace—the Swagger Team ceiling—typically moves in under a week. The export process also provides a useful audit of inactive or obsolete specifications.

When SwaggerHub still makes sense

SwaggerHub remains a better fit in three cases:

Organization-scale API governance. If you need custom style guides, Spectral rulesets, and standardization reporting across hundreds of specifications and many teams, SwaggerHub Enterprise is built for that.
Pact-based contract testing. If Pact contract testing between microservices is fundamental to your workflow, SwaggerHub’s dedicated Contract Testing module is a differentiator.
API gateway synchronization. If specifications must sync bi-directionally with AWS API Gateway, Azure API Management, or Apigee, SwaggerHub provides mature integrations.

The switch to Apidog is most compelling when the primary work is API design, testing, documentation, and mocking—and Swagger’s metered executions, branded portal, and add-on model create unnecessary overhead.

For another design-first comparison, see the Stoplight comparison. Stoplight is now also part of SmartBear.

Frequently asked questions

What does SwaggerHub cost now?

Under the relaunched Swagger platform:

Individual starts at $22.80 per user/month.
Team starts at $34.44 per user/month.
Enterprise starts at $58.80 per user/month.
Enterprise Plus is quote-based.

Enterprise SSO ($6), Portal Pro ($29.40), Contract Testing Pro ($23), and Test Pro ($30) are per-user monthly add-ons.

Is Apidog really unlimited where SwaggerHub is metered?

Yes. APIs, requests, test runs, and scheduled executions are unlimited on every Apidog plan, including the free tier. SwaggerHub meters test executions at 50–100 per month below Enterprise Plus and caps APIs at 10–50 on lower tiers.

Can I import SwaggerHub specs into Apidog?

Yes. Export your specification as OpenAPI YAML or JSON, then import it directly. Schemas, endpoints, examples, and descriptions carry over. Resolve shared Domains into the specification during export.

Does Apidog support spec-first design like SwaggerHub?

Yes. Apidog provides visual and code-based OpenAPI editing with branch-based review. The specification can drive docs, mocks, and tests automatically.

It does not provide organization-wide custom linting rulesets, which remains a SwaggerHub governance advantage.

What about SwaggerHub API gateway integrations?

Apidog does not natively push specifications to AWS, Azure, or Apigee gateways. If gateway synchronization is a hard requirement, account for that before migrating. Both platforms still support OpenAPI export and import.

Design the spec, then run it

Import one SwaggerHub specification into Apidog and use it to generate documentation, a schema-aware mock server, and a test scenario. Then schedule that scenario for your next deployment without tracking execution limits.

Download Apidog. A four-person team can evaluate it on the free plan, and additional seats cost $9 per user/month versus $34.44 plus add-ons for Swagger Team.

The Best Postman Alternative

Hassann — Tue, 04 Aug 2026 06:45:57 +0000

Postman ended free team collaboration on March 1, 2026. The Free plan is now limited to one user and can’t create a team, so the moment a second developer needs access to your collections, someone has to pull out a credit card. If you’re searching for a Postman alternative, that change is probably why.

Try Apidog today

Here’s the direct answer: Apidog is a Postman alternative for teams. It keeps a forever-free plan for up to four users, runs existing Postman scripts without rewrites, and combines API design, debugging, testing, mocking, and documentation in one platform.

This guide covers what changed in Postman, how pricing compares, and how to migrate an existing collection.

Why developers are leaving Postman in 2026

Postman is still a capable API client. The reasons teams switch are mostly about collaboration, pricing, and keeping API artifacts synchronized.

Team collaboration is now paid. Before March 2026, a Free workspace could invite up to three collaborators. Now, the Free plan is limited to one user. Collaborating teams pay from $14 per user per month, billed annually, according to Postman’s pricing page. For a four-person team, that is roughly $672 per year. See the latest limitations of Postman’s free plan for the full breakdown.
Specs and collections are separate. In Postman, an OpenAPI spec and a collection are separate objects. When an API changes, teams may need to update the spec, collection, mock, and tests independently.
The client can feel heavier than a request tool. Sign-in walls, workspaces, monitors, and AI features can sit between you and a request. See why Postman feels slow and bloated in 2026.

Postman is not a bad product. But for teams, its pricing and manual synchronization work can add overhead.

What the change costs a real team

At Postman’s entry team price of $14 per user per month, billed annually, costs scale quickly. Apidog is free for up to four users, then costs $9 per user per month beyond that.

Seats	Postman per year	Apidog per year	Difference
1	$0 (Free plan)	$0 (free plan)	$0
4	$672	$0	$672
10	$1,680	$1,080	$600
20	$3,360	$2,160	$1,200

A solo developer pays nothing on either tool. Postman’s Free plan still includes unlimited collection runs and mock server usage; the cost gap begins when a second person needs access.

Once a team exceeds Apidog’s four free users, every seat is billed at $9 per user per month. The free tier no longer applies after four seats, but the per-seat price remains $5 lower than Postman’s entry team price.

Subscription cost is not the only consideration. Teams using Postman for collaboration may also use separate tools for documentation and mocks. Consolidating those workflows can reduce additional tooling overhead.

The answer: Apidog

Apidog is an API development platform used by over 500,000 developers. It covers visual API design, debugging, automated testing, smart mocking, and published documentation, using the OpenAPI spec as a single source of truth.

Three details matter when comparing it with Postman:

The free plan supports four users. Small teams can design, debug, and test together at no cost, with unlimited APIs, requests, projects, and collection runs.
It is 100% Postman syntax compatible. Pre-request scripts, post-request scripts, variables, and dynamic values carry over without rewriting test logic.
Paid plans start at $9 per user per month. That compares with Postman’s $14+ for collaboration.

Where Apidog goes beyond Postman

One spec drives everything

Apidog is design-first. Your API spec, requests, mock servers, and documentation stay linked.

When you rename a field in the spec, related examples, mocks, and docs update with it. Instead of maintaining detached API artifacts, you can use the spec as the source of truth.

Testing without run caps or glue code

Apidog provides visual test orchestration:

Add endpoints to a scenario.
Add assertions visually.
Extract values from one response.
Reuse those values in later requests.
Chain API calls without writing glue code.

It also includes scheduled runs, performance testing, shareable online test reports, and a self-hosted runner for automation inside your network. Runs are unlimited on every plan, including the free plan.

For CI, the Apidog CLI runs the same scenarios in Jenkins, GitLab CI, or GitHub Actions and outputs HTML reports per build. If you currently use Newman, review these Postman CLI alternatives for CI.

Mocking with schema-aware responses

Apidog’s smart mock engine reads your schema and returns realistic fake data without manual configuration.

For example:

A field named email returns an email value.
A field named avatar_url returns an image URL.

Postman supports fixed-response mocks, but not schema-aware mocks or a self-hosted mock option. With a schema-driven mock server, frontend work can begin before the backend is complete.

Documentation you can publish

Apidog generates interactive API documentation from your spec. You can publish it on a custom domain with:

Custom layouts
Markdown pages
Versioning
A built-in “try it” console

Because the docs come from the same spec used for testing and mocking, the documentation stays aligned with the API contract.

Built for AI-assisted development

Apidog includes an MCP server that exposes API specs to AI agents, an MCP client for debugging and testing MCP servers visually, and a CLI for agent-driven documentation, mocks, and tests.

The MCP client supports STDIO and streamable HTTP, with OAuth 2.0 auto-configuration.

Install the agent skill with:

npm install -g apidog-cli
npx apidog-cli install-skill

Learn more in what is Apidog MCP Server.

Postman vs. Apidog at a glance

	Postman	Apidog
Free plan users	1 (no team)	4
Entry price for teams	From $14/user/month	$9/user/month
Spec-to-collection sync	Manual	Automatic
Visual test orchestration	No	Yes
Smart schema-based mocking	No	Yes
Self-hosted mock server / runner	No	Yes
Docs on a custom domain	No	Yes
MCP client and visual MCP debugging	No	Yes
Postman script compatibility	Native	100% compatible
G2 usability score	Category average 9.0	9.4, ranked #1

Migrate from Postman in one import

Apidog imports Postman collections and environments directly.

Export your collection and environment from Postman.
Import both files into Apidog.
Open an imported request and send it.
Verify your pre-request scripts, assertions, and variables.
Generate or refine an API spec to make it the source of truth.

Because Apidog supports Postman script syntax, pre-request logic, test assertions, and variables work as-is. For a migration path used by teams switching after the npm supply-chain scare, see secure API testing and migration after the Axios npm attack.

Your first hour after switching

A migration does not need to become a large project. Use this first-hour checklist.

Minutes 0–10: Import collections and environments

Export your Postman collections and environments, then use Apidog’s one-click import.

Your requests, folder structure, headers, authentication settings, and variables arrive intact.

Minutes 10–20: Run existing scripts

Open an imported request and send it.

Pre-request scripts, assertions, and dynamic values execute unchanged because Apidog is compatible with Postman script syntax.

Minutes 20–30: Generate a spec

A Postman collection describes requests, but it does not define a contract.

Generate a structured API spec from imported requests, then use that spec to keep collections, mocks, and docs synchronized.

Minutes 30–40: Enable smart mocking

With a spec in place, enable the mock server.

The mock engine returns data that matches your schema without requiring mock rules for every field. Point your frontend application to the mock URL to unblock UI development while backend work is in progress.

Minutes 40–50: Build one visual test scenario

Create a scenario with a few endpoints:

Call an authentication endpoint.
Extract a token from the response.
Pass the token into a subsequent request.
Add an assertion for the expected status code or response body.

You now have a chained API test without writing glue code.

Minutes 50–60: Run it in CI

Install the CLI and run the scenario from your terminal:

npm install -g apidog-cli
apidog run scenario --scenario-id 12345 --env production

The same command works in Jenkins, GitLab CI, and GitHub Actions. Each run generates an HTML report. See how to manage APIs with Apidog CLI for the command reference.

Enterprise controls, if you need them

Larger organizations typically need to evaluate access controls, data residency, and account provisioning alongside API tooling.

Apidog provides:

SSO through Okta and Microsoft Entra ID. Access follows your identity provider.
SCIM provisioning. New hires can receive seats automatically, while departing users lose access through directory synchronization.
Project-level RBAC. Permissions can apply per project rather than only per workspace.
European data residency. Apidog Europe is a GDPR-compliant deployment with data stored in AWS Ireland and Germany.
Self-hosted runner. Scheduled tests and automation can execute on your own infrastructure, so internal APIs do not leave your network.

On G2, Apidog scores 9.8 for Ease of Admin, 9.7 for Ease of Use, and 9.7 for Meets Requirements, against category averages around 9.0 to 9.1, with a 4.8 out of 5 overall rating.

One caveat: Postman’s enterprise governance ecosystem has been available longer. If your organization has established processes around it, include that work in your migration plan.

When Postman still makes sense

Postman can still be the right choice in some cases:

You are a solo developer who never shares a workspace.
You rely on Postman’s VS Code extension. Apidog offers an IntelliJ IDEA plugin instead.
Your organization has deeply integrated Postman Enterprise governance workflows.

For teams primarily affected by pricing, collaboration limits, or spec drift, Apidog is a practical alternative. If price is the main concern, see the best Postman alternative for teams priced out of Postman.

Frequently asked questions

Is Apidog free for teams?

Yes. The free plan includes four users with unlimited APIs, requests, projects, and test runs. Postman’s Free plan dropped to one user in March 2026 and cannot create a team.

Will my Postman test scripts work in Apidog?

Yes. Apidog is 100% compatible with Postman script syntax, including pre-request scripts, test assertions, and dynamic variables. Import the collection and run it.

Does Apidog replace my documentation tool too?

For API reference documentation, yes. Apidog publishes interactive documentation with custom domains, versioning, and Markdown pages from the same spec your team tests against.

How does Apidog pricing compare to Postman?

Apidog’s paid plans start at $9 per user per month, compared with Postman’s $14+ for team collaboration. A four-person team on Apidog’s free plan saves roughly $672 per year versus Postman’s entry team pricing.

Do I need to rewrite my Newman or CI setup?

No. The Apidog CLI can take Newman’s place in your pipeline.

Install it with:

npm install -g apidog-cli

Then run a scenario:

apidog run scenario --scenario-id 12345 --env production

You can run this from Jenkins, GitLab CI, or GitHub Actions. Each run outputs an HTML report that can be published as a build artifact.

Does Apidog have a VS Code extension?

No. Postman has the advantage for VS Code integration. Apidog offers an IntelliJ IDEA plugin, desktop apps, and a web app for the same workflows in a browser.

If sending requests directly from VS Code is central to your workflow, factor that into the decision.

Try it with your own collections

The fastest way to evaluate a Postman alternative is to import real work.

Download Apidog, import a Postman collection, and run an existing test scenario. Your team of four can work for free, your scripts run unchanged, and your spec can stay synchronized with the mocks, docs, and tests built on top of it.

For the full comparison, see the Apidog vs. Postman comparison page.

The Best Bruno Alternative

Hassann — Tue, 04 Aug 2026 06:44:52 +0000

Bruno won a loyal following by doing the opposite of Postman: collections live as plain-text files in your Git repo, requests execute on your machine, and no cloud account sits between you and your API. If you are looking for a Bruno alternative, the trigger is usually practical: your team needs a mock server, hosted documentation, or collaboration that does not depend on pull requests.

Try Apidog today

The direct answer: Apidog is a Bruno alternative for teams that want local request execution plus platform features Bruno intentionally leaves out. It adds schema-aware mocking, real-time workspaces, published API documentation, and visual test orchestration, with a free plan for up to four users.

What Bruno gets right

Bruno's core design works well for Git-first API workflows:

Collections as code. Each request is stored in a .bru file. Collections can live beside application code, produce readable diffs, and follow the same review workflow as source changes. See Bruno's documentation for the file format.
Offline and private by design. Requests run locally, nothing is synced to a vendor cloud, and the open-source client is free.
A real business model. Bruno offers Pro at $6 and Ultimate at $11 per user per month, according to Bruno's pricing page. Ultimate includes SAML SSO, SCIM, external secret managers such as HashiCorp Vault and AWS Secrets Manager, and audit logs.

The limitations are not bugs. They follow from a Git-only architecture. Whether they matter depends on what your team needs beyond sending and reviewing requests.

Where the Git-only model runs out

No built-in mock server

Bruno does not include a mock server. If frontend work needs endpoints before the backend is ready, you must add and maintain a separate tool such as JSON Server or WireMock.

The practical result is another configuration surface, another deployment path, and another tool for developers to learn. The available workarounds are covered in Does Bruno have a mock server?.

Collaboration means pull requests

Git is excellent for history and code review. It is slower for the daily API iteration loop:

A teammate changes a request.
They commit and push it.
You pull the change.
You can finally run or inspect it.

Bruno has no hosted shared workspace or real-time presence. That is manageable for a small Git-native team, but it adds ceremony when a squad is changing endpoints, examples, and test cases throughout a sprint. See Bruno for teams: cloud sync alternatives for the team-scale trade-offs.

Docs stay on your laptop

Bruno can generate documentation from a collection, but publishing requires exporting HTML and hosting it yourself. There is no built-in docs portal, custom-domain flow, or interactive console for API consumers.

OpenAPI is primarily an import/export format in this workflow rather than the live center of the project. On Bruno Pro, OpenAPI syncs are also metered at five per month.

The client is the whole product

Bruno provides a CLI for CI runs, but it does not provide scheduled test runs, performance testing, online reports, or a browser client for teammates who do not install desktop software.

If your needs stop at request folders and assertions, that can be enough. Once you need orchestration, scheduling, reporting, or shared workflows, you are assembling a separate toolchain again. See a Bruno alternative that does more than Git for that comparison.

The alternative: Apidog

Apidog is an API development platform used by over 500,000 developers. It combines API design, debugging, testing, mocking, and documentation in one workspace, using the OpenAPI specification as the single source of truth.

For teams moving from Bruno, focus on these differences:

Requests still execute locally. The Apidog desktop client sends requests from your machine. Localhost services and APIs behind a VPN remain accessible without routing request traffic through a vendor server.
The free plan supports four users. It includes unlimited APIs, requests, projects, and test runs. The comparison is not only about price; it is about what each free tier includes.
Mocking, docs, and testing are built in. You do not need to maintain separate tools for these workflows.
Real-time workspaces reduce Git ceremony. Teammates can see changes as they are made, while workspace-level version history remains available.

What you gain when you switch

A mock server that reads your schema

Apidog's smart mock engine generates responses directly from your API specification with no manual response setup required.

For example, a schema like this:

type: object
properties:
  email:
    type: string
  created_at:
    type: string
    format: date-time

can produce realistic values such as an email address and timestamp. Point the frontend at the generated mock URL so UI development can begin before the backend is complete.

Self-hosted mock deployment is available when data cannot leave your network.

Documentation people can visit

Apidog publishes interactive API documentation from the same specification used for testing. This includes custom domains, versioning, Markdown pages, and a built-in Try It console.

The implementation benefit is simple: update the spec once, and documentation updates from that same source. There is no HTML export step and no separately hosted documentation artifact to keep in sync.

Tests with orchestration, schedules, and reports

Use the visual test builder to chain endpoints into a scenario, pass values between steps, and add assertions without writing glue code.

For example, a scenario can:

Authenticate and save an access token.
Create a resource using that token.
Fetch the resource by ID.
Assert the response status and schema.
Run on a schedule and publish an online report.

You can also run scenarios in CI with the Apidog CLI:

npm install -g apidog-cli
apidog run scenario --scenario-id 12345 --env staging

Runs are unlimited on every plan, including the free plan.

Automatic response validation against the spec

Bruno runs the assertions you define. Apidog can additionally validate each response against the endpoint schema automatically.

This catches contract drift involving:

Status codes
Required properties
Data types
Enum values
Numeric ranges
Unexpected properties

When an implementation stops matching the API contract, validation can surface it on the next request instead of after a consumer reports a bug. See the full breakdown on the Apidog vs Bruno comparison page.

An AI-ready API surface

Apidog includes an MCP server that exposes API specs to coding agents, plus an MCP client for debugging MCP servers visually.

For teams using Claude Code or Cursor, an agent can read the specification, run requests, and update documentation through Apidog's MCP server. Bruno does not provide an equivalent MCP surface today.

Bruno vs Apidog at a glance

	Bruno	Apidog
Price for teams	Pro $6 / Ultimate $11 per user/mo	Free up to 4 users, then $9 per user/mo
Local request execution	Yes	Yes, with desktop client
Collection storage	Git, plain-text `.bru` files	Cloud workspace with version history
Real-time collaboration	No, Git sync	Yes
Built-in mock server	No	Yes, schema-aware and self-hostable
Hosted docs with custom domain	No, self-hosted HTML export	Yes
Scheduled tests and online reports	No	Yes
Performance testing	No	Yes
SSO / SCIM / audit logs	Yes, on Ultimate	Yes, on Enterprise
Secret managers	Yes, on Ultimate	Yes, Vault on Enterprise
MCP server for AI agents	No	Yes

Two details are worth keeping in mind:

Bruno Ultimate is a real enterprise tier. It includes SSO, SCIM, secret-manager integrations, and audit logs. On those features, both products offer enterprise capabilities, and Bruno is cheaper per seat.
Git-native collection storage is a real advantage when compliance or review processes require collections to remain in a repository. Apidog addresses spec-review workflows differently through branches in its visual designer.

Migrating from Bruno

Apidog imports Bruno collections directly. The migration guide on the comparison page describes the process as one click.

Use this migration path:

Import your Bruno collections. Folder structure, headers, authentication, and environments carry over. You can also import an OpenAPI definition instead.
Generate a specification from imported requests. This changes the workflow: the spec becomes the source of truth, while mocks and documentation derive from it.
Rebuild CI runs with the Apidog CLI. Each run produces an HTML report.
Keep Git where it is useful. If your team still stores specifications in a repository, use apidog spec sync to synchronize the spec with Git from the command line.

apidog spec sync

The mechanical migration typically takes an afternoon. The larger workflow change is that a spec update can propagate to mocks, documentation, and tests without a separate synchronization step.

When Bruno still makes sense

Bruno remains a strong choice when:

Your collections must live in Git for policy or compliance reasons.
You are a solo developer or small team that only needs a fast local request runner.
Your organization already uses Bruno Ultimate for SSO and secret-manager integration.
Git-based reviews are more important than hosted collaboration, mocks, docs, and scheduled testing.

Switch when your team needs built-in mocking, public documentation, scheduled tests, or real-time collaboration. Those capabilities do not naturally fit Bruno's Git-only architecture.

Frequently asked questions

Is Apidog free like Bruno?

Bruno's client is open source and free forever. Apidog's free plan supports four users with unlimited APIs, requests, and test runs.

For teams of four or fewer, both can cost $0. The difference is in the included workflow: Apidog provides mocking, hosted docs, and scheduled testing, while Bruno provides Git-native storage.

Does Apidog execute requests locally like Bruno?

Yes. The Apidog desktop client sends requests from your machine, so localhost services and APIs on internal networks work as they do in Bruno.

Can I import Bruno collections into Apidog?

Yes. Apidog imports Bruno collections directly, including requests, folders, authentication, and environments. You can then generate a structured specification from those requests. OpenAPI import is also available.

Does Bruno have SSO and audit logs?

Yes. Bruno Ultimate, at $11 per user per month, includes SAML SSO, SCIM provisioning, external secret managers, and audit logs.

If those are your only requirements, Bruno covers them. Features Bruno does not offer at any price include a built-in mock server, hosted docs portal, real-time workspace, and scheduled test runs.

What replaces Bruno's Git review workflow in Apidog?

Apidog's visual designer supports branches, so teams can propose, review, and merge specification changes inside the platform. Version history is tracked at the workspace level rather than only in a repository.

Try it with a real collection

The fastest evaluation is to import one Bruno collection and enable the mock server:

Download Apidog.
Import an existing Bruno collection.
Generate or review the API specification.
Enable the mock server.
Point your frontend at the generated mock URL.
Publish the documentation page for internal or external consumers.

If schema-aware mock data and published documentation save more team time than Git-native storage saves, the decision becomes clear. Review the full feature list on the Apidog vs Bruno comparison page.

Qwen 3.8 vs Kimi K3: China's Two Open-Weight Giants, Compared

Hassann — Mon, 03 Aug 2026 07:32:18 +0000

July 2026 became a two-horse month for open-weight frontier models, and both contenders came from China. Moonshot AI released Kimi K3 on July 16, while Alibaba previewed Qwen 3.8-Max on July 19 and made it generally available in early August. Both are trillion-parameter mixture-of-experts (MoE) models, both work with Claude Code-style agent harnesses, and both target lower API costs than US frontier labs. The practical differences are in what you can download today, which inputs each model accepts, and what high-volume usage costs.

Try Apidog today

For the full Alibaba specification breakdown, see the Qwen 3.8-Max explainer.

Benchmark caveat: No independent, same-harness head-to-head benchmark of Qwen 3.8-Max and Kimi K3 was available as of August 3, 2026. Benchmark results below come from vendor-published tables and should be treated as indicative rather than conclusive.

The timeline: what shipped, and when

Release timing matters because “open weights” means different things for these models today.

Kimi K3

Kimi K3 launched on July 16, 2026. Moonshot promised open weights at launch and published them 11 days later, on July 27, as a 594 GB MXFP4 release on Hugging Face.

You can currently:

Download the weights
Apply additional quantization
Run the model on your own infrastructure
Evaluate a pinned model version without relying on a hosted endpoint

Qwen 3.8-Max

Qwen 3.8-Max was previewed on July 19 and reached general availability on Alibaba Cloud Model Studio in early August, according to the official Qwen release post.

Alibaba stated that weights would be released to Hugging Face and ModelScope “next week,” placing the expected date around August 10. As of August 3, 2026, those weights are not downloadable.

Implementation takeaway: If you need self-hosting this week, Kimi K3 is the only practical option. If hosted API access is acceptable, evaluate both.

Parameters: two trillion-scale MoE models

Both models use sparse MoE architectures. The total parameter count describes model size, while active parameters per token better reflect serving compute.

Spec	Qwen 3.8-Max	Kimi K3
Total parameters	2.4T	2.8T
Active parameters per token	95B	104B
Activation ratio	~4%	~3.7%
Architecture base	Qwen 3.5 foundation, MoE	MoE
Open-weight format	Promised (~Aug 10)	MXFP4, 594 GB on Hugging Face

Qwen 3.8-Max has 400B fewer total parameters and activates 9B fewer parameters per token than Kimi K3. That does not automatically make it more capable, but it can reduce serving cost when all other factors are equal.

For self-hosting, K3’s 594 GB MXFP4 download is the more useful number. This is multi-node deployment territory before accounting for long-context KV cache requirements. Qwen 3.8-Max will likely require similar infrastructure once its weights are available.

For most teams:

Use hosted endpoints for production evaluation.
Self-host only when compliance, research, model pinning, or custom inference infrastructure justify the operational cost.

Openness today: available weights vs a release promise

Kimi K3 is open in practice today. Its weights are public, so you can inspect the repository, review license terms, generate community quantizations, fine-tune the model, and host it independently.

Qwen 3.8-Max would be the first Qwen Max-tier model released with open weights. Previous Qwen Max models were API-only. However, until the Hugging Face or ModelScope repository is available, Qwen 3.8-Max remains an API model with an announced future weight release.

Decision rule:

Need downloadable weights now: choose Kimi K3.
Can wait until around August 10: re-check Qwen’s release status and compare license terms, quantization support, and community tooling.

Modality: Qwen supports images; K3 is text-only

This is the largest functional difference.

Qwen 3.8-Max supports text and image inputs, as shown in its official model configuration:

{
  "input_modalities": ["text", "image"]
}

Alibaba’s launch materials also demonstrate 200-plus-page PDF understanding and 100-hour video comprehension through memory graphs. Treat those demonstrations as vendor examples, not as documented API input types. Image input, however, is available through the API.

Kimi K3 is a text model. If your workflow includes screenshots, scanned PDFs, UI interpretation, or computer-use tasks, you need to add a separate vision model and build the routing, data transfer, and result-merging logic yourself.

Choose based on input type

Workload	Better fit
Text-only coding agents	Either model
Repository analysis	Either model
Screenshot debugging	Qwen 3.8-Max
OCR and scanned documents	Qwen 3.8-Max
UI automation or computer-use agents	Qwen 3.8-Max
Self-hosted text-only inference	Kimi K3

Context, output limits, and API compatibility

Qwen 3.8-Max provides:

Context window: 1,000,000 tokens
Maximum output: 65,536 tokens
Reasoning control: reasoning_effort
Reasoning levels: xhigh by default, plus medium and low
Thinking output: preserved by default
Billing: thinking and non-thinking output are billed at the same rate

Qwen is available through Alibaba Cloud Model Studio with regional base URLs for:

Beijing
Singapore
US-Virginia

It exposes both OpenAI-compatible and Anthropic-compatible API shapes. The Anthropic-compatible endpoint makes it straightforward to use with Claude Code-style tooling.

For example, configure a compatible harness with environment variables similar to:

export ANTHROPIC_BASE_URL="https://your-dashscope-anthropic-endpoint"
export ANTHROPIC_MODEL="qwen3.8-max"
export ANTHROPIC_API_KEY="your-api-key"

Check the Model Studio models page for current regional availability and endpoint details.

If you test multiple regions, store each base URL in a separate environment. Tools such as Apidog let you switch environment variables without editing the request itself.

Kimi K3 also supports the Anthropic protocol and works with Claude Code-style harnesses. For current K3 endpoint configuration and limits, refer to the Kimi K3 explainer.

Pricing: Qwen is cheaper on list price

Published prices are per million tokens.

Rate	Qwen 3.8-Max	Kimi K3
Input	$2.00	$3.00
Output	$6.00	$15.00
Cache-hit input	$0.20	$0.30
Tiering	Flat across the full 1M context	Per Moonshot’s published schedule

Qwen 3.8-Max charges $2 per million input tokens and $6 per million output tokens across its full 1M-token context window, according to the official Model Studio pricing page.

For Qwen:

Explicit cache creation costs 125% of the input rate.
Cache hits cost 10% of the input rate.
A 1M-token free quota is available in the Singapore region for 90 days.

Kimi K3 pricing is:

$3 per million input tokens
$15 per million output tokens
$0.30 per million cached input tokens

Estimate cost from your token mix

Use this basic formula before choosing a default model:

estimated_cost =
  (input_tokens / 1_000_000 * input_rate) +
  (output_tokens / 1_000_000 * output_rate) +
  (cached_input_tokens / 1_000_000 * cache_hit_rate)

For output-heavy agent workloads, Qwen’s pricing advantage is substantial:

Qwen output: $6 / million tokens
Kimi K3 output: $15 / million tokens

That makes Kimi K3 output 2.5x more expensive on list price.

However, do not estimate Qwen cost from visible final output alone. Its default reasoning_effort=xhigh generates thinking tokens, and those tokens are billed as output. Lower the reasoning effort during evaluation if your workload does not need maximum reasoning depth.

For worked examples, see the Qwen 3.8 pricing breakdown.

Benchmarks: compare methodology before scores

The key fact is simple: there is no independent benchmark table evaluating Qwen 3.8-Max and Kimi K3 under the same harness, prompt set, sampling configuration, and scaffolding.

What is available

Alibaba published Qwen 3.8-Max results against Claude Opus 4.8, Fable 5, GPT-5.6 Sol, and Qwen 3.7-Max.
Moonshot published a Kimi K3 launch benchmark table against a similar frontier-model set.
Both sets of results are vendor-run.

What is not available

Independent Qwen 3.8-Max vs Kimi K3 testing
Artificial Analysis results for Qwen 3.8-Max at the time of writing
Cross-vendor benchmark runs where both models used the same harness and setup

Alibaba’s published results, run largely through the Claude Code harness according to Alibaba’s own disclosure, include:

Benchmark	Qwen 3.8-Max	Claude Opus 4.8	Fable 5	GPT-5.6 Sol
Terminal Bench 2.1	86.6	84.6	84.6	88.8
SWE-bench Pro	67.7	69.2	80.0	64.6
PaperBench	93.0	80.3	88.8	90.5
GPQA Diamond	92.6	92.0	92.6	94.1
HLE	43.6	45.7	53.3	47.2

Alibaba’s own table includes losses as well as wins. Qwen 3.8-Max trails Fable 5 on SWE-bench Pro and trails every listed model on HLE. Its stronger reported areas include PaperBench, instruction following on IFBench, and multimodal evaluations.

Alibaba also reports results on in-house benchmarks such as QwenSWEBench and CoWorkBench. Those results cannot be directly compared with external vendor tables.

Moonshot’s K3 launch table showed K3 outperforming Claude Opus 4.8 across Moonshot’s selected benchmark rows, while trailing Fable 5 and GPT-5.6 Sol overall. See the Kimi K3 vs Claude Opus 4.8 comparison for those claims and caveats.

Practical conclusion: Treat both vendor benchmark tables as signals for which workloads to test, not as a purchasing decision. For more detail on Alibaba’s reported results, see the Qwen 3.8 benchmarks analysis.

Run your own head-to-head in Apidog

The most useful evaluation is a repeatable test against tasks from your own product or repository.

Both models provide OpenAI-compatible chat-completions endpoints, so you can use one request payload and switch only the target environment.

1. Create two environments

Create one environment for Qwen and one for Kimi K3.

Environment: qwen-3.8-max
BASE_URL=https://your-dashscope-endpoint
MODEL=qwen3.8-max
API_KEY=your-qwen-key

Environment: kimi-k3
BASE_URL=https://your-moonshot-endpoint
MODEL=your-k3-model-id
API_KEY=your-kimi-key

2. Save one shared request

Use a production-like prompt rather than a benchmark riddle.

POST {{BASE_URL}}/v1/chat/completions
Authorization: Bearer {{API_KEY}}
Content-Type: application/json

{
  "model": "{{MODEL}}",
  "messages": [
    {
      "role": "system",
      "content": "You are a senior backend engineer. Return actionable implementation steps."
    },
    {
      "role": "user",
      "content": "Review this service design and identify likely failure modes: ..."
    }
  ],
  "stream": true
}

3. Test the same workload on both models

For each prompt, record:

End-to-end latency
Time to first token
Output token count
Reasoning token behavior, if exposed
Schema validity
Task completion rate
Tool-call correctness
Actual invoice cost

4. Add repeatable assertions

Add checks for conditions that matter in your application:

- Response status is 200
- Response includes required JSON keys
- Latency stays below your threshold
- Output includes required domain terms
- Tool-call arguments match the expected schema

Apidog can keep the request shared while you swap environments, inspect full response bodies, compare latency, and debug SSE streams. If your application renders thinking content, streaming inspection is especially useful.

Download Apidog and run 10 to 20 representative prompts through both endpoints before committing to either model.

The scorecard

Axis	Winner today	Caveat
Total/active parameters	Qwen 3.8-Max	Leaner at 2.4T/95B vs 2.8T/104B; mainly relevant to serving cost
Open weights today	Kimi K3	Live on Hugging Face as a 594 GB MXFP4 release
Modality	Qwen 3.8-Max	Supports text and image input
Context window	Qwen 3.8-Max	1M flat tier and 65,536-token maximum output
Price	Qwen 3.8-Max	$2/$6 vs $3/$15, but xhigh reasoning increases billed output
Benchmarks	No call	Both tables are vendor-run
Harness ecosystem	Tie	Both support Claude Code-style Anthropic-protocol integrations
Track record on open-weight delivery	Kimi K3	Weights shipped 11 days after launch; Qwen’s release was still pending

Which model should you use?

Pick Kimi K3 if

You need downloadable weights immediately.
Your compliance requirements require a model you can pin, audit, and self-host.
Your workload is text-only.
Your input volume is high enough that cache-hit pricing dominates your costs.

Pick Qwen 3.8-Max if

Your workload includes images, screenshots, or scanned documents.
You run output-heavy agents for code generation or multi-step task execution.
You need a 1M-token context window without tiered pricing.
You want lower list prices for both input and output tokens.

Wait if open weights are the deciding factor

If Qwen’s weights arrive around August 10 as promised, the openness comparison changes. At that point, compare:

License terms
Available quantizations
Inference stack support
Hardware requirements
Your own task-level evaluation results

The actionable conclusion is not to trust either vendor’s benchmark table alone. Both models are credible, lower-cost, harness-compatible frontier options. Route the same real prompts through both endpoints, measure quality, latency, and cost, then choose based on your production workload.

FAQ

Is Kimi K3 more open than Qwen 3.8-Max?

As of August 3, 2026, yes. Kimi K3 weights have been available on Hugging Face since July 27 as a 594 GB MXFP4 release. Qwen 3.8-Max weights were promised for around August 10 but were not downloadable yet.

If Alibaba releases the weights, both models become open-weight options. The next comparison points will be license terms, quantization quality, and community support. Until then, only K3 can be self-hosted. See the local K3 guide for deployment considerations.

Which model is better at coding?

There is no honest definitive answer yet.

Both vendors publish strong coding and agentic benchmark results, but they use their own evaluation setups. No independent same-harness comparison exists. Alibaba’s own results show Qwen 3.8-Max losing to Fable 5 on SWE-bench Pro, which reinforces why a single vendor table should not determine your choice.

Run both models against tasks from your own repository:

Bug fixes
Test generation
Refactoring
Code review
Tool invocation
Multi-file implementation tasks

Can I use both models in Claude Code?

Yes. Both models expose Anthropic-compatible endpoints.

For Qwen 3.8-Max, configure ANTHROPIC_BASE_URL with the DashScope Anthropic endpoint and set:

export ANTHROPIC_MODEL="qwen3.8-max"

Kimi K3 supports the same general configuration pattern through Moonshot’s endpoint. This shared protocol compatibility makes side-by-side testing inexpensive to set up.

Which model is cheaper for a typical agent workload?

On list price, Qwen 3.8-Max is cheaper:

Qwen 3.8-Max: $2 input / $6 output per million tokens
Kimi K3:       $3 input / $15 output per million tokens

Agent loops often generate many output tokens, which makes Qwen’s $6 output rate attractive compared with K3’s $15 rate.

Two qualifiers matter:

K3’s $0.30 cache-hit rate can keep input-heavy, heavily cached workloads competitive.
Qwen’s default xhigh reasoning setting bills thinking tokens as output, so real costs can exceed simple visible-output estimates.

Measure your actual input, cached-input, output, and reasoning token mix before making a cost decision.

Qwen 3.8 vs Qwen 3.7 Max: What Actually Changed

Hassann — Mon, 03 Aug 2026 07:02:13 +0000

Alibaba released Qwen 3.8-Max in early August 2026. If you run qwen3.7-max in production, the upgrade decision is practical: 3.8-Max improves agentic and research performance, accepts image input, has a lower list price, and is the first Max-class Qwen model with promised open weights.

Try Apidog today

The trade-off is current cost. Qwen 3.7-Max has a limited-time 50% promotion, so it is cheaper than 3.8-Max today. Benchmark gains also vary by workload: some are large, while GPQA Diamond is effectively unchanged.

For a full introduction to the new model, read the Qwen 3.8-Max explainer. For the previous flagship, see what Qwen 3.7 brought to the table.

Before you compare benchmarks

Every benchmark below comes from Alibaba’s official Qwen 3.8 release post. This matters because both Qwen models were evaluated in the same vendor run, making the deltas internally consistent.

However:

Independent verification is still pending.
Most coding rows use the Claude Code harness.
Several benchmarks are Qwen in-house evaluations.

Use these numbers to prioritize what to test in your own workload, not as a substitute for production evaluation.

Quick comparison

What changed	Qwen 3.7-Max	Qwen 3.8-Max
Terminal Bench 2.1	74.5	86.6
SWE-bench Pro	60.6	67.7
PaperBench	64.8	93.0
IFBench	79.1	82.8
GPQA Diamond	92.4	92.6
HLE	41.4	43.6
List price, per 1M input tokens	$2.50	$2.00
List price, per 1M output tokens	$7.50	$6.00
Current promotional price	$1.25 in / $3.75 out	$2 in / $6 out
Image input	No	Yes
Disclosed architecture	Not disclosed	2.4T total, 95B active MoE
Open weights	Never released	Promised “next week” (~Aug. 10)
Context window	1M tokens	1M tokens

Benchmark deltas: prioritize agentic and research workloads

The largest gains are on long-horizon tasks that require planning, execution, and self-correction.

Terminal Bench 2.1: 74.5 → 86.6

This 12-point increase is the strongest reason to test 3.8-Max for terminal-driven agents.

In Alibaba’s table, Qwen 3.8-Max scores above Claude Opus 4.8 and Fable 5, both at 84.6 on this row. GPT-5.6 Sol remains ahead at 88.8.

Test 3.8-Max first if your agent:

Runs shell commands
Debugs deployment failures
Edits repositories through terminal tools
Performs multi-step operational work

SWE-bench Pro: 60.6 → 67.7

A 7-point gain on software engineering tasks is meaningful, but it does not make Qwen the leader in Alibaba’s comparison. Fable 5 scores 80.0 on the same row.

Use this result as a reason to benchmark Qwen 3.8-Max against your own issue-resolution tasks, not as proof that it is the best option for every coding workflow.

PaperBench: 64.8 → 93.0

This is the largest change in the table: a 28-point increase for reproducing AI research papers.

If your application handles research reproduction, long technical documents, or multi-step scientific reasoning, this is the benchmark delta most likely to affect your results.

IFBench: 79.1 → 82.8

Instruction following improves by nearly 4 points. Qwen 3.7-Max was already strong in Alibaba’s comparison, so 3.8-Max extends an existing strength.

This improvement is relevant for:

Structured extraction
Tool-use prompts
Multi-constraint generation
Workflow agents with strict output formats

GPQA Diamond: 92.4 → 92.6

This result is effectively flat.

If your workload is mostly graduate-level science Q&A or knowledge retrieval, the upgrade may not improve output quality enough to offset the current promotional price of 3.7-Max.

HLE: 41.4 → 43.6

Humanity’s Last Exam improves by 2 points, but Qwen 3.8-Max still trails frontier models in Alibaba’s table. Fable 5 scores 53.3, while GPT-5.6 Sol scores 47.2.

What the benchmark pattern means

Use Qwen 3.8-Max when your workload depends on:

Terminal and computer-use agents
Research workflows
Long technical reasoning
Stronger instruction following
Image-based inputs

Keep Qwen 3.7-Max when your workload is primarily general Q&A, summarization, or knowledge tasks that already meet your quality bar.

For the full benchmark table and methodology details, see the Qwen 3.8 benchmarks breakdown.

Architecture: Qwen 3.8-Max is easier to capacity-plan

Qwen 3.8-Max is a 2.4 trillion parameter mixture-of-experts model with 95B active parameters per forward pass. It is built on the Qwen 3.5 architectural foundation.

The active ratio is roughly 4%, which matters for serving economics: inference compute is based on the active parameters rather than all 2.4T parameters.

Alibaba did not publish equivalent scale details for Qwen 3.7-Max. Qwen 3.8-Max has documented parameter counts and architecture information in the Model Studio documentation and release post.

For open-weight context, Kimi K3 is larger at 2.8T total parameters and 104B active parameters.

Multimodal support: image input is new

Qwen 3.7-Max is text-only. Qwen 3.8-Max accepts image input natively.

Alibaba’s multimodal table reports these notable Qwen 3.8-Max scores:

MathVision: 95.2
LogicVista: 91.9
OSWorld-Verified: 86.1

There is no Qwen 3.7-Max comparison because the older model does not support images.

This can simplify applications that previously routed different inputs to separate text and vision models, including:

Screenshot understanding
Document-image processing
UI automation
Chart extraction

Alibaba also demonstrates long-document and video understanding in its release post. Treat those as demonstrated capabilities and verify supported request formats in the API documentation before designing around them.

Pricing: Qwen 3.8-Max is cheaper at list price, but not today

At list price, Qwen 3.8-Max costs:

$2 per 1M input tokens
$6 per 1M output tokens

Qwen 3.7-Max lists at:

$2.50 per 1M input tokens
$7.50 per 1M output tokens

That makes Qwen 3.8-Max 20% cheaper than its predecessor at standard pricing.

However, Qwen 3.7-Max currently has a limited-time 50% promotion:

$1.25 per 1M input tokens
$3.75 per 1M output tokens

At those promotional rates, 3.7-Max costs 38% less than 3.8-Max. Check the official Model Studio pricing page before setting production budgets.

Account for reasoning-token cost

Qwen 3.8-Max defaults to:

{
  "reasoning_effort": "xhigh"
}

Thinking tokens are billed as output tokens. A model with a lower listed input price can still cost more per request if it generates substantial reasoning output.

Before switching, test at least three settings:

{
  "reasoning_effort": "xhigh"
}

{
  "reasoning_effort": "medium"
}

{
  "reasoning_effort": "low"
}

Compare task success, latency, output-token usage, and total cost. For cache economics and per-task calculations, see the Qwen 3.8 pricing guide.

If Max-tier pricing does not fit your workload, qwen3.7-plus is the value option at $0.40 input and $1.60 output per 1M tokens, currently 20% off. See the Plus vs. Max comparison.

Open weights: promised, but not available yet

Qwen 3.7-Max never shipped open weights, and Alibaba never indicated that it would.

Qwen 3.8-Max is different: Alibaba’s release post says weights will be released on Hugging Face and ModelScope “next week,” which indicates roughly August 10, 2026.

As of August 3, 2026, the weights are not downloadable. Plan based on what is available today, not on a future release.

Even if weights arrive, a 2.4T parameter model is a multi-node self-hosting project, including when quantized. For most teams, the immediate effect is more likely to be third-party hosted options and pricing pressure rather than self-hosting in a local rack.

If open weights are a procurement or compliance requirement, that distinction may determine the decision:

Qwen 3.7-Max: no open weights
Qwen 3.8-Max: open weights promised

What does not change

Context window: 1M tokens

Both models support a 1M-token context window. Qwen 3.8-Max does not expand it, but it maintains the same capacity at a flat list price across the full context.

API migration: mostly a model ID swap

Both models run through Alibaba Cloud Model Studio using OpenAI-compatible endpoints.

For basic text requests, switch model IDs:

- "model": "qwen3.7-max"
+ "model": "qwen3.8-max"

This is not a full API migration project.

Qwen 3.8-Max also adds an Anthropic-compatible API surface. If your stack uses that protocol, exercise it with a client such as Apidog before changing production traffic.

Reasoning controls are explicit

Qwen 3.8-Max documents these controls:

reasoning_effort
enable_thinking
preserve_thinking

reasoning_effort supports xhigh by default, plus medium and low.

If you previously relied on implicit reasoning behavior from Qwen 3.7-Max, make the setting explicit in 3.8-Max and include it in your benchmark matrix.

Choose an upgrade path

Upgrade to Qwen 3.8-Max now if

Your workload is agentic, research-heavy, or image-based.

Prioritize an upgrade when you need:

Terminal agents
Research-paper reproduction
Screenshot or document-image processing
UI automation
Better instruction following
A path toward open weights

The Terminal Bench increase from 74.5 to 86.6 and PaperBench increase from 64.8 to 93.0 are large enough to validate against production tasks immediately.

Keep Qwen 3.7-Max during the promotion if

Your workload is mostly in the flat-performance zone:

General Q&A
Summarization
General chat
Knowledge-oriented requests

GPQA Diamond changes by only 0.2 points. If 3.7-Max already meets your quality threshold, its $1.25 / $3.75 promotional rate is currently the best per-token price among the two Max models.

Set a recurring reminder to check the promotion. If it ends, Qwen 3.8-Max at $2 / $6 becomes cheaper than Qwen 3.7-Max at its $2.50 / $7.50 list price.

Move to `qwen3.7-plus` if cost is the primary constraint

At $0.40 input and $1.60 output per 1M tokens, qwen3.7-plus is 5x cheaper than Qwen 3.8-Max on input tokens.

Use it for routine tasks such as:

Classification
Extraction
Templated generation
Simple transformations
Low-risk structured outputs

Read the Qwen 3.7-Plus overview before paying for Max-tier capability by default.

Test the switch before changing production

Vendor benchmarks cannot predict behavior on your prompts, schemas, tools, and data. Run a side-by-side evaluation using representative production requests.

1. Use one endpoint and parameterize the model

Both models use the same OpenAI-compatible Model Studio API surface. Define the model ID as an environment variable:

{
  "model": "{{qwen_model}}",
  "messages": [
    {
      "role": "user",
      "content": "Summarize this deployment incident and return valid JSON."
    }
  ],
  "reasoning_effort": "{{reasoning_effort}}"
}

2. Create two environments

Create environments such as:

qwen-3.7-max
  qwen_model=qwen3.7-max
  reasoning_effort=xhigh

qwen-3.8-max
  qwen_model=qwen3.8-max
  reasoning_effort=xhigh

3. Run the same test set against both

Include requests that represent actual traffic:

Common requests
Known failure cases
Tool-use tasks
Long-context prompts
Structured-output prompts
Image inputs, if relevant

4. Compare more than output quality

Track:

Metric	Why it matters
Task success rate	Measures whether the answer solves the problem
JSON/schema validity	Detects integration failures
Input and output tokens	Determines actual cost
Thinking-token usage	Important because it bills as output
Latency	Affects user experience and agent loops
Retry rate	Often reveals hidden reliability costs

In Apidog, point a collection at the Model Studio OpenAI-compatible endpoint, then switch environments between qwen3.7-max and qwen3.8-max. Save representative requests as test scenarios and rerun them when Alibaba updates models or changes promotional pricing.

That turns an upgrade debate into a repeatable evaluation. Download Apidog and compare both models against your own traffic before changing a production configuration.

FAQ

Is Qwen 3.8-Max cheaper than Qwen 3.7-Max?

At list price, yes:

Qwen 3.8-Max: $2 input / $6 output per 1M tokens
Qwen 3.7-Max: $2.50 input / $7.50 output per 1M tokens

At current promotional pricing, no. Qwen 3.7-Max costs $1.25 input / $3.75 output per 1M tokens, 38% less than Qwen 3.8-Max. The promotion has no published end date.

See the Qwen 3.8 pricing guide for the full cost breakdown.

Do I need to change code to switch from `qwen3.7-max` to `qwen3.8-max`?

For basic usage, no. Both models use the same OpenAI-compatible Model Studio endpoints, so the minimum change is:

- "model": "qwen3.7-max"
+ "model": "qwen3.8-max"

Set reasoning_effort explicitly because 3.8-Max defaults to xhigh, and thinking tokens bill as output. Image requests are a 3.8-Max-only feature and require the standard image-input message format.

Does Qwen 3.7-Max have open weights?

No. Qwen 3.7-Max has not released open weights.

Qwen 3.8-Max is the first Max-class model with promised weights, expected on Hugging Face and ModelScope around August 10, 2026. As of August 3, 2026, they are not downloadable.

Is Qwen 3.8-Max better than Claude or GPT?

It depends on the benchmark and these are Alibaba’s own results.

In Alibaba’s table, Qwen 3.8-Max:

Beats Opus 4.8 and Fable 5 on Terminal Bench 2.1
Leads the comparison on PaperBench and IFBench
Trails Fable 5 on SWE-bench Pro, 67.7 versus 80.0
Trails frontier models on HLE

Wait for third-party evaluations before making broad capability claims.

Qwen 3.8 for Coding: 16-Day Autonomous Runs and the Claude Code Connection

Hassann — Mon, 03 Aug 2026 06:40:35 +0000

Most model launches pitch coding ability the same way: here’s a HumanEval score and a snippet of a model writing binary search. Alibaba took a different route with Qwen 3.8-Max. The claim is not just that it writes good functions—it can run a software project for weeks by opening issues, merging pull requests, and shipping features without a human in the loop.

Try Apidog today

That is a bold claim, and it deserves scrutiny. This post covers Alibaba’s three coding showcases at launch—all vendor demos, with one public repository you can audit—the coding benchmark results behind them, and the practical setup for using qwen3.8-max with Claude Code, Codex, Qoder, Qwen Code, and OpenClaw. It also covers how to test the API output produced by generated code.

If you are new to the model, start with what Qwen 3.8 is: 2.4T total parameters, 95B active parameters, a 1M-token context window, and open weights promised for the week after launch. This article stays focused on coding. Everything below reflects the state of things as of August 3, 2026.

What Alibaba is actually claiming

The framing in the official Qwen 3.8 release post is autonomy over snippets. Alibaba positions Qwen 3.8-Max as a model that can keep a long-horizon engineering task in context: plan work, execute across days, recover from mistakes, and produce something reviewable at the end.

Three details make this more interesting than a typical launch-day demo:

The demos are long. Sixteen days is a different operating regime from a 20-minute agent benchmark. Error recovery, context management, and task drift matter much more at that scale.
One demo is public. You can inspect the repository, commits, pull requests, and issues instead of relying on screenshots.
The harness is a competitor’s. Alibaba ran most coding benchmarks using the Claude Code harness and published an official configuration for it.

The standard caveat applies throughout this post: every number comes from Alibaba’s launch materials. As of early August 2026, there is no independent verification. Treat the showcases as demos, not audits.

The three coding showcases

oh-my-cli: 16 days of autonomous development

The headline demo is an unattended run building a command-line tool. As of July 30, Alibaba said the run had operated for 16 days and produced:

265 commits
127 pull requests
151 issues

The model opened, worked, and closed those issues itself.

The repository is public at qwen-code-dev-bot/oh-my-cli. That is the most useful part of the showcase because you can audit it directly.

When reviewing the repository, check more than commit volume:

Do pull requests actually fix the issues they reference?
Does the agent create artificial work just to close it later?
Are tests added alongside changes?
How does it recover from regressions it introduces?
Are issue descriptions and PR summaries specific enough to be useful to a human reviewer?

Those signals tell you more about long-horizon reliability than a single benchmark score.

The paper reproduction run: research code, not app code

The second demo targets reproducing a machine learning research paper from scratch. According to Alibaba, the run:

Took roughly 125 hours
Produced about 7,600 lines of code
Ran 33 GPU training rounds
Reproduced 6 findings from the paper
Beat the paper’s reported AIME24 result by 2.7 points

Research reproduction is unforgiving. Environments break, hyperparameters can be buried in footnotes, and one silent implementation bug can invalidate a training run hours later.

The demo aligns with Qwen 3.8-Max’s strongest coding-related benchmark result: PaperBench.

The Tianchi contest: 24 hours against human teams

The third showcase placed the model in a live data science competition on Alibaba’s Tianchi platform with a 24-hour limit.

Alibaba reports that Qwen 3.8-Max:

Made 45 submissions
Iterated based on submission scores
Reached a final accuracy of 0.853
Finished ahead of 458 of 526 human teams

The model did not win, but it reportedly beat 87% of the field. This demo measures something the other two do not: rapid iteration under a deadline, where every score informs the next attempt.

One caveat matters here: Tianchi is Alibaba’s own platform. The demo may be real, but the vendor controlled the venue.

The coding benchmarks behind the demos

Alibaba published a full benchmark table at launch. These are the coding-relevant rows.

Benchmark	Qwen 3.8-Max	Best rival, per Alibaba’s table
Terminal Bench 2.1	86.6	88.8, GPT-5.6 Sol
SWE-bench Pro	67.7	80.0, Fable 5
PaperBench	93.0	90.5, GPT-5.6 Sol

Three practical takeaways:

Terminal Bench 2.1: 86.6. Alibaba’s table puts Qwen 3.8-Max ahead of Claude Opus 4.8 and Fable 5, both at 84.6, for terminal-driven agentic work. This is the result most closely associated with the oh-my-cli demo.
SWE-bench Pro: 67.7. This is the weaker result. Fable 5 scores 80.0 in the same table. For repository-scale bug fixing—the benchmark closest to “fix this issue in my codebase”—Qwen 3.8-Max trails the reported leader by more than 12 points.
PaperBench: 93.0. This is the model’s strongest flagship result and supports the paper-reproduction showcase directly.

Read the fine print, too: Alibaba ran most coding benchmarks on the Claude Code harness, including runs for rival models. The table footnotes also note that Fable 5 results may involve fallbacks.

Harness choice can materially affect agent benchmark scores. A vendor-run benchmark table on a specific harness is one data point, not a final verdict.

The useful part for developers is that Alibaba optimized for a harness you may already use and published the relevant configuration.

How to actually code with Qwen 3.8 today

Qwen 3.8-Max is GA on Alibaba Cloud Model Studio. Alibaba published official configurations for five coding tools at launch.

You need a DashScope API key from home.qwencloud.com.

According to the official Model Studio pricing page, pricing is:

$2 per million input tokens
$6 per million output tokens
Flat pricing across the full 1M-token context window

Claude Code

Qwen 3.8-Max exposes an Anthropic-compatible endpoint. Configure Claude Code with these environment variables:

export ANTHROPIC_BASE_URL=https://dashscope-intl.aliyuncs.com/apps/anthropic
export ANTHROPIC_AUTH_TOKEN=your-dashscope-api-key
export ANTHROPIC_MODEL=qwen3.8-max

Then start Claude Code normally.

This routes Claude Code requests to Qwen 3.8-Max instead of Claude. Since Alibaba ran its coding benchmarks with this harness, this setup has the least distance between the published measurements and your local workflow.

A practical workflow:

# Set credentials for the current shell session
export ANTHROPIC_BASE_URL=https://dashscope-intl.aliyuncs.com/apps/anthropic
export ANTHROPIC_AUTH_TOKEN="$DASHSCOPE_API_KEY"
export ANTHROPIC_MODEL=qwen3.8-max

# Start Claude Code inside your repository
cd your-project
claude

Before giving the agent a broad task, start with a bounded change:

Read the repository README and package configuration.
Identify the test command.
Fix only the failing test in src/auth/token.ts.
Run the relevant test suite and summarize the changed files.
Do not modify dependencies.

This gives you a quick signal on repository understanding, tool use, and test discipline before assigning a larger refactor.

Codex

Codex requires a provider entry in its configuration:

model = "qwen3.8-max"
model_provider = "qwencloud"

[model_providers.qwencloud]
name = "QwenCloud"
base_url = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
env_key = "DASHSCOPE_API_KEY"
context_window = 1000000

This uses the OpenAI-compatible endpoint instead of the Anthropic-compatible endpoint.

Set the API key before starting Codex:

export DASHSCOPE_API_KEY=your-dashscope-api-key

The model and key are the same; only the API protocol changes.

Qoder, Qwen Code, and OpenClaw

The remaining integrations are more direct:

Qoder CLI: Select qwen3.8-max as the model. It is a first-party integration.
Qwen Code: Set DASHSCOPE_API_KEY, then select qwen3.8-max. If you already use earlier Qwen coding models, the workflow does not otherwise change.
OpenClaw: The official configuration sets the model ID and maxTokens to 65,536, which is also the model’s maximum output length.

Use the latest configuration from the launch post rather than treating a blog snapshot as a permanent config reference.

Set reasoning effort deliberately

Qwen 3.8-Max supports reasoning_effort with three levels:

xhigh — default
medium
low

Choose it based on the task.

Task type	Recommended reasoning effort
Multi-file refactor	`xhigh`
Debugging a non-obvious failure	`xhigh`
Planning an agentic implementation	`xhigh`
Renaming symbols	`low`
Updating docstrings	`low`
Mechanical formatting or simple edits	`low`

Use xhigh for work where the model must inspect, plan, test, and revise. The showcase runs represent this mode.

Use low for simple edits where extended reasoning adds latency and output-token cost without improving the result.

Thinking tokens are billed as output tokens at $6 per million. For long-running coding agents, use the highest effort level only where it adds value.

If Qwen 3.8-Max is more model than the task requires, the earlier Qwen3 Coder line remains available for dedicated coding work, while Qwen3 Coder Flash targets faster and cheaper workloads. For another open-weight model in this space, see how Kimi K3 handles coding work.

Testing what the model builds: the Apidog step

Every autonomous coding demo has the same gap: the model can write code that calls APIs, but generated API behavior still needs verification.

An agent can produce thousands of lines that compile and pass local tests while still:

Calling the wrong endpoint
Sending an invalid request body
Mishandling 429 Too Many Requests
Skipping authentication edge cases
Assuming a response shape that differs from production

Two practices help close that gap.

1. Test the endpoints your generated code calls

When Qwen 3.8-Max scaffolds a service or writes an API client, import the relevant API specification into Apidog and test the endpoints directly.

Validate at least:

Authentication and authorization flows
Required and optional request fields
Invalid payloads
Error response formats
Rate-limit behavior
Pagination and cursor handling
Timeout and retry behavior

For example, if the generated client calls POST /users, test both the expected request and invalid variations before merging:

{
  "email": "developer@example.com",
  "name": "Dev User"
}

Then test invalid input:

{
  "email": "not-an-email"
}

Verify that your generated client handles the actual status code and error body, rather than the response it assumed existed.

If you are evaluating Qwen 3.8-Max’s own API before committing to it, the Qwen 3.8 API guide covers the OpenAI-compatible and Anthropic-compatible setup in detail. Apidog can help inspect both protocol shapes side by side, including streaming responses and reasoning deltas.

2. Mock APIs so agent runs do not hit production

This becomes more important as runs get longer.

Do not let an unattended coding agent make unrestricted production calls. A multi-day run can trigger rate limits, mutate data, or generate unexpected bills.

Use Apidog mock servers to provide realistic API responses without touching real systems.

A safe implementation pattern looks like this:

# Local or agent-run environment
API_BASE_URL=https://your-mock-server.example

# Human-reviewed production deployment
API_BASE_URL=https://api.example.com

For an agent-generated API client, make the base URL configurable:

export const apiBaseUrl =
  process.env.API_BASE_URL ?? "https://your-mock-server.example";

Then point the agent environment at the mock URL during development and switch to the real URL only after a human review.

Download Apidog for free to set up a mock server in a few minutes.

The broader pattern is simple: the more autonomy you give a coding model, the more the API layer becomes a control surface. You may not review every commit in real time, but you can control what generated code is allowed to call.

FAQs

Is Qwen 3.8 good for coding?

Based on Alibaba’s own numbers, it is strong at agentic and research-style coding:

Terminal Bench 2.1: 86.6
PaperBench: 93.0

It is less competitive on repository-scale bug fixing:

SWE-bench Pro: 67.7
Fable 5, in Alibaba’s table: 80.0

All results are vendor-run and had no independent verification as of early August 2026. The practical read is that Qwen 3.8-Max appears suited to long-horizon autonomous work, but is not the reported leader for conventional issue-fixing tasks.

Can I use Qwen 3.8 in Claude Code?

Yes. Configure Claude Code with:

export ANTHROPIC_BASE_URL=https://dashscope-intl.aliyuncs.com/apps/anthropic
export ANTHROPIC_AUTH_TOKEN=your-dashscope-api-key
export ANTHROPIC_MODEL=qwen3.8-max

Alibaba published this configuration and used the Claude Code harness for most of its coding benchmarks.

How much does coding with Qwen 3.8 cost?

Alibaba lists:

$2 per million input tokens
$6 per million output tokens
Flat pricing across the 1M-token context window

Thinking tokens are billed as output tokens. Since xhigh is the default reasoning effort, budget above the nominal request size for long agentic sessions.

For cost details and comparisons, see the Qwen 3.8 benchmarks breakdown.

Was the 16-day oh-my-cli run really autonomous?

That is Alibaba’s claim. The useful difference from most vendor demos is that the artifact is public: qwen-code-dev-bot/oh-my-cli had 265 commits, 127 pull requests, and 151 issues as of July 30, 2026.

You can inspect the repository yourself and judge whether the code quality supports the autonomy claim.

Qwen 3.8 Benchmarks: What Alibaba's Table Shows, and What It Doesn't

Hassann — Mon, 03 Aug 2026 04:21:50 +0000

For two weeks, the Qwen 3.8 story had a gap: July press previews promised a frontier-class model but shipped no scores. On August 3, 2026, Alibaba published its official Qwen 3.8-Max release post, including benchmark tables comparing it with Claude Opus 4.8, Fable 5, GPT-5.6 Sol, Qwen3.7-Max, Gemini 3.1 Pro, and GPT-5.6 Sol.

Try Apidog today

The tables show real strengths, clear losses, and important methodology caveats. This post breaks down the published results, then shows how to evaluate Qwen 3.8-Max against your own API workload instead of relying on vendor benchmarks. For model parameters, pricing, and access details, see the Qwen 3.8-Max explainer.

All scores below come from Alibaba’s published table, with leaderboard footnotes dated August 3, 2026. No independent evaluations were available at the time of writing, so treat each number as a vendor-reported result.

The table at a glance

Alibaba’s headline text-model results are below. Higher is better for every benchmark.

Benchmark	Qwen 3.8-Max	Claude Opus 4.8	Fable 5	GPT-5.6 Sol	Qwen3.7-Max
Terminal Bench 2.1	86.6	84.6	84.6	88.8	74.5
SWE-bench Pro	67.7	69.2	80.0	64.6	60.6
PaperBench	93.0	80.3	88.8	90.5	64.8
GPQA Diamond	92.6	92.0	92.6	94.1	92.4
IFBench	82.8	62.2	63.5	72.7	79.1
HLE (Humanity’s Last Exam)	43.6	45.7	53.3	47.2	41.4

Source: Alibaba’s vendor-run benchmark table.

Where Qwen 3.8-Max wins

PaperBench: strongest flagship result

On PaperBench, which measures whether a model can reproduce research-paper results, Qwen 3.8-Max scores 93.0:

GPT-5.6 Sol: 90.5
Fable 5: 88.8
Claude Opus 4.8: 80.3
Qwen3.7-Max: 64.8

The jump from Qwen3.7-Max is 28.2 points. That is substantial and should be validated independently, but it suggests a meaningful improvement in long-horizon research tasks if the result holds.

IFBench: instruction following

Qwen 3.8-Max scores 82.8 on IFBench. The nearest non-Qwen model in Alibaba’s table is GPT-5.6 Sol at 72.7.

Model	IFBench
Qwen 3.8-Max	82.8
Qwen3.7-Max	79.1
GPT-5.6 Sol	72.7
Fable 5	63.5
Claude Opus 4.8	62.2

Since Qwen3.7-Max already led this row, instruction following appears to be a sustained Qwen strength rather than a one-generation result.

Terminal Bench 2.1: ahead of Claude, behind GPT-5.6 Sol

Alibaba reports 86.6 for Qwen 3.8-Max on Terminal Bench 2.1:

GPT-5.6 Sol: 88.8
Qwen 3.8-Max: 86.6
Claude Opus 4.8: 84.6
Fable 5: 84.6

This is a second-place result, not an overall win. Still, it puts Qwen 3.8-Max ahead of both Claude Opus 4.8 and Fable 5 in Alibaba’s agentic terminal evaluation.

Multimodal performance

The separate multimodal table is Qwen 3.8-Max’s strongest overall showing. Alibaba reports:

MathVision: 95.2
LogicVista: 91.9
OSWorld-Verified: 86.1

The model also leads nearly every OCR row in the published table. Claude Opus 4.8 and Fable 5 are text-focused in this comparison, so they do not directly compete across these multimodal benchmarks. Against Gemini 3.1 Pro and GPT-5.6 Sol, visual reasoning and document intelligence are Qwen 3.8-Max’s clearest reported differentiators.

For the comparison with the other major open-weight summer release, note that Kimi K3 is text-only. See the full Qwen 3.8 vs. Kimi K3 comparison.

Where it loses

Alibaba included weaker rows in the table. Three are especially relevant for developers evaluating coding and general-reasoning workloads.

HLE: behind every flagship competitor

On Humanity’s Last Exam (HLE), Qwen 3.8-Max scores 43.6:

Model	HLE
Fable 5	53.3
GPT-5.6 Sol	47.2
Claude Opus 4.8	45.7
Qwen 3.8-Max	43.6
Qwen3.7-Max	41.4

Qwen 3.8-Max improves on its predecessor, but it ranks last among the four flagship models in this table. Since HLE is a broad-knowledge benchmark designed to resist narrow benchmark tuning, this result deserves significant weight.

SWE-bench Pro: far behind Fable 5

On SWE-bench Pro, Qwen 3.8-Max scores 67.7:

Fable 5: 80.0
Claude Opus 4.8: 69.2
Qwen 3.8-Max: 67.7
GPT-5.6 Sol: 64.6
Qwen3.7-Max: 60.6

The model improves meaningfully over Qwen3.7-Max, but it is 12.3 points behind Fable 5. Both statements can be true at once:

Qwen 3.8-Max beats Claude Opus 4.8 on Terminal Bench 2.1.
Qwen 3.8-Max trails Fable 5 substantially on SWE-bench Pro.

DeepSWE and difficult agentic coding tasks

Alibaba’s own table also shows Qwen 3.8-Max behind frontier models on DeepSWE. The coding pattern is consistent:

Competitive on terminal-driven agent tasks.
Less competitive on the deepest software-engineering evaluations.

Read the methodology before using the numbers

Vendor benchmark tables are useful, but they are not independent measurements. Four details from Alibaba’s publication affect how these results should be interpreted.

1. Every result is vendor-run

Alibaba evaluated Qwen 3.8-Max and its competitors. This is common for launch announcements, but vendors control details that can affect results:

Benchmark version
System prompt and prompting strategy
Sampling settings
Retry policy
Tool configuration
Agent harness

That does not make the results invalid. It means they should be treated as claims that require confirmation.

2. Most coding benchmarks used the Claude Code harness

Alibaba ran most coding benchmarks with Claude Code, Anthropic’s agent harness, connected to Qwen 3.8-Max through an Anthropic-compatible API.

This is useful because the models were evaluated in a shared tool environment. However, agentic benchmarks are harness-sensitive. A score in this setup should be read as:

Qwen 3.8-Max running inside the Claude Code harness

—not as a harness-independent coding capability score.

3. Several benchmarks are Qwen-built

QwenSWEBench, QwenQoderBench, CoWorkBench, and RecreationBench were built by the Qwen team.

In-house benchmarks can capture capabilities that public benchmarks miss. However, they are different evidence from public evaluations such as SWE-bench Pro. When using a score from the table, identify whether the benchmark is public or vendor-built first.

4. The Fable 5 footnote matters

Alibaba’s table notes that:

“Fable5 results may involve fallbacks.”

That means the Fable 5 column may not represent clean, direct model execution in every case. Since Fable 5 is often the model Qwen 3.8-Max trails in the table, this caveat matters when comparing exact deltas.

This methodology issue is not unique to Alibaba. Anthropic, OpenAI, and Google also publish self-run benchmark tables. The same pattern appeared in the Kimi K3 benchmarks breakdown: vendor tables are useful starting points, not final measurements.

How to evaluate the next vendor table

Use this checklist before adopting benchmark claims:

Who ran the evaluation?

Vendor-reported competitor numbers should receive extra scrutiny.
Which harness and settings were used?

Tool use, retry behavior, prompts, and agent harnesses can change coding results.
Which benchmarks are vendor-built?

In-house evaluations may be useful, but they are not equivalent to public benchmarks.
Did you read the footnotes?

Notes such as “may involve fallbacks” can materially change how a result should be interpreted.
What is missing?

Compare current tables with earlier generations to find rows that disappeared. The previous cross-vendor comparison can help identify missing benchmarks.
Is there an independent second source?

Waiting for community leaderboards or third-party evaluations often provides more actionable evidence than a launch-day table.

Run your own evaluation instead

A public benchmark can help shortlist models. Your production prompts should make the final decision.

Qwen 3.8-Max is available through Alibaba Cloud Model Studio as qwen3.8-max, listed on the official models page. It supports both OpenAI-compatible and Anthropic-compatible APIs.

A practical evaluation workflow in Apidog looks like this:

Create a request for Qwen 3.8-Max using the Model Studio chat-completions endpoint.
Create an identical request for your baseline model, such as Qwen3.7-Max, Kimi K3, Claude, or GPT.
Save 20–30 representative production prompts as a test scenario.
Add assertions for the properties your application requires:
- Valid JSON
- Required fields present
- Correct schema
- No unsupported tool calls
- Latency below your threshold
Run both scenarios with the same inputs.
Compare pass rate, output quality, response time, and cost.

For Qwen 3.8-Max specifically, test two details:

The model defaults to reasoning_effort: xhigh, so benchmark the reasoning level you would actually deploy.
If you plan to use the Anthropic-compatible endpoint, test it separately. That protocol shape is also the one Alibaba used for most of its coding benchmarks.

Use Apidog to configure each endpoint as an environment and generate side-by-side test reports for your actual workload. You can download Apidog and start collecting first-party data before independent leaderboards publish theirs.

Frequently asked questions

Are the Qwen 3.8 benchmark numbers independently verified?

No. As of August 3, 2026, the published numbers come from Alibaba’s own table. Artificial Analysis and community leaderboards had not yet published Qwen 3.8-Max scores at the time of writing. Treat the results as vendor-reported until independent evaluations are available.

What is Qwen 3.8-Max’s best benchmark result?

Its strongest flagship-table row is PaperBench at 93.0, ahead of GPT-5.6 Sol at 90.5, Fable 5 at 88.8, and Claude Opus 4.8 at 80.3. In the multimodal table, MathVision at 95.2 and the OCR results are its strongest reported results.

Where does Qwen 3.8-Max clearly lose?

Qwen 3.8-Max scores 43.6 on HLE, ranking last among the four flagships and behind Fable 5’s 53.3. It also scores 67.7 on SWE-bench Pro versus Fable 5’s 80.0, and trails on DeepSWE. Deep software-engineering evaluations and broad-knowledge exams are its weaker areas in Alibaba’s table.

How much better is Qwen 3.8 than Qwen 3.7-Max on benchmarks?

Alibaba reports substantial generation-over-generation gains:

Terminal Bench 2.1: 74.5 → 86.6
SWE-bench Pro: 60.6 → 67.7
PaperBench: 64.8 → 93.0

Whether the upgrade is worthwhile depends on your workload, modality requirements, latency targets, and price. See the full Qwen 3.8 vs. Qwen 3.7 comparison.

How to Use Qwen 3.8 for Free

Hassann — Mon, 03 Aug 2026 04:20:58 +0000

Alibaba released Qwen 3.8-Max in early August 2026, and search results are already full of “free forever” claims that do not match the actual terms. This guide summarizes Alibaba’s official options as of August 3, 2026.

Try Apidog today

There are four practical routes. Two work now, one is promised with a release date, and one is a fallback. For the model details first—2.4 trillion total parameters, 95B active parameters, and a 1M-token context—read the Qwen 3.8 overview.

Quick comparison

Route	Free?	Works today?	Catch
Qwen Chat	Yes	Yes	Consumer app; no API
Model Studio API quota	1M tokens	Yes	Singapore region only; expires after 90 days
Open weights / self-hosting	Weights free	Not yet	Promised “next week”; hardware is not free
Older Qwen models	Yes	Yes	Not Qwen 3.8-Max

Route 1: Qwen Chat for zero-setup testing

The fastest way to try Qwen 3.8-Max is Qwen Chat. Sign in, select the model, and use it without a card or cloud-console setup. The official release post lists this as the default way to try the model.

Use Qwen Chat when you want to:

Test general prompt quality.
Try image and document understanding.
Compare outputs manually before committing to an API evaluation.

Do not use it as an API benchmark. Qwen Chat does not provide API keys or automation, and its system prompts and app settings can differ from raw API behavior.

Verdict: A real free option for exploration, but not a developer integration route.

Route 2: Model Studio’s 1M-token API quota

For implementation work, Alibaba Cloud Model Studio is the route that matters. New activations receive 1 million free tokens for qwen3.8-max.

Before you activate it, account for these constraints from the Model Studio pricing page.

1. Use the Singapore endpoint

The free quota only applies to the Singapore international region:

https://dashscope-intl.aliyuncs.com/compatible-mode/v1

Using Beijing or US-Virginia endpoints means billing starts from the first token. If your application requires a US endpoint for latency or compliance reasons, this quota does not apply.

2. Use the quota within 90 days

The quota expires 90 days after activation. Unused tokens do not roll over.

Activate the service when you are ready to evaluate the model, not months before the project starts.

3. Plan for paid usage after the quota

After the free quota is exhausted or expires, pricing is:

$2 per million input tokens
$6 per million output tokens

The rate applies across the full 1M-token context. Set billing alerts before testing. For workload examples, see the Qwen 3.8 pricing guide.

Set up the API

Create a Model Studio account.
Activate the Model Studio service.
Generate an API key.
Store it in an environment variable:

export DASHSCOPE_API_KEY="your_api_key"

Configure your client to use the Singapore base URL.

The Model Studio model catalog lists qwen3.8-max among the recommended models. The service supports an OpenAI-compatible protocol and an Anthropic-compatible endpoint.

For streaming, reasoning output, and both protocol formats, follow the Qwen 3.8 API walkthrough.

Avoid the default reasoning-cost trap

Qwen 3.8-Max defaults to:

reasoning_effort=xhigh

Thinking tokens are billed as output tokens. A hard prompt can generate thousands of reasoning tokens before the visible answer starts.

For routine tasks, lower the setting:

reasoning_effort=low

or:

reasoning_effort=medium

Reserve xhigh for tasks that actually need extended reasoning.

Make the 1M-token quota last

Use these practices during evaluation:

Validate requests before adding retry loops.

Build and inspect individual requests first. This avoids repeatedly burning tokens on malformed payloads, incorrect model names, or bad environment configuration.
Mock responses after validating their shape.

Once you have a representative response, mock it for frontend, agent, and integration work. Save live API calls for final verification.
Track usage per request.

Token counts are returned in response bodies. Log them during testing so you can calculate your actual burn rate.

You can use Apidog to send requests interactively, inspect streaming responses, and switch between Singapore, Beijing, and US environments without editing application code each time.

Download Apidog if you want to use this workflow.

Verdict: This is the best current developer option. It is genuinely free for 90 days, but only in Singapore and only up to 1M tokens.

Route 3: Open weights are promised, not available yet

Alibaba says Qwen 3.8-Max will be the first Qwen-Max-class model with open weights. The weights are expected on Hugging Face and ModelScope “next week,” which places the target around August 10, 2026.

As of August 3, 2026, the weights are not downloadable. There is nothing to quantize, self-host, or run locally.

Treat any tutorial claiming to run Qwen 3.8-Max locally before the weights are actually released with skepticism.

Self-hosting will not be consumer hardware friendly

Even after release, “free weights” does not mean free local inference.

Qwen 3.8-Max has 2.4T total parameters. A comparable model, Kimi K3, shipped as 594 GB of weights even with aggressive MXFP4 quantization. Qwen 3.8-Max will still require hundreds of gigabytes of storage and a multi-GPU, realistically multi-node, serving setup.

That means:

No consumer GPU can host it.
No typical workstation can host it.
Self-hosting requires serious infrastructure.

For the practical hardware and serving implications, see the guide to running Kimi K3 locally.

The likely benefit of open weights is not laptop inference. It is competition among third-party hosts, which can lead to cheaper hosted API access than first-party pricing.

Verdict: Not available yet. Check again in mid-August and budget for hosted infrastructure rather than local hardware.

Route 4: Use older Qwen models for truly free alternatives

If your real requirement is “a capable Qwen model at zero cost,” rather than Qwen 3.8-Max specifically, older Qwen models are a practical fallback.

Smaller open-weight Qwen models can run on hardware developers actually own, and older models have no-cost access routes that do not expire after 90 days. See the guide to using Qwen 3.7 for free.

The trade-off is straightforward: you lose the benchmark improvements that made Qwen 3.8-Max notable. For side projects, classification, prototype agents, or learning the Qwen API format, older models may be enough.

What does not exist

As of August 3, 2026:

There is no unlimited free API tier. The 1M-token quota expires.
There is no free API tier outside Singapore. Beijing and US-Virginia bill from the first token.
There are no downloadable Qwen 3.8-Max weights yet. “Next week” is a promise, not a release.
There is no official free Qwen 3.8-Max tier on third-party aggregators. Before weights ship, verify what model is actually behind any “free 3.8-Max” claim.

FAQ

Is the Qwen 3.8 API actually free?

Partly. Alibaba Cloud Model Studio provides 1 million free tokens for 90 days in the Singapore region. After that, pricing is $2 per million input tokens and $6 per million output tokens.

Can I download and run Qwen 3.8 locally now?

No. The weights are expected on Hugging Face and ModelScope around August 10, 2026, but had not shipped as of August 3. When they arrive, expect hundreds of gigabytes of weights and multi-GPU serving requirements.

How is this different from Kimi K3’s free options?

Kimi K3 weights are already available, so self-hosting is possible today. Qwen 3.8-Max self-hosting is still pending. Both models are too large for consumer hardware. For comparison, read the guide to using Kimi K3 for free.

Does the free quota include thinking tokens?

Yes, but thinking tokens consume the quota. Because reasoning_effort defaults to xhigh, lower it for normal calls unless you need extended reasoning.

Bottom line

Free Qwen 3.8-Max access is real, but limited:

Use Qwen Chat for casual testing.
Use Model Studio for 1M API tokens in Singapore within a 90-day window.
Wait for open weights if you want third-party hosting options.
Use older Qwen models if you need a long-term zero-cost alternative.

If you take the API route, spend quota on evaluation instead of debugging. Prototype requests in Apidog, mock validated responses during development, and reserve live calls for the tests that determine whether Qwen 3.8-Max belongs in your stack.

Qwen 3.8 Pricing Explained: $2 Input / $6 Output Across a 1M Context

Hassann — Mon, 03 Aug 2026 04:18:55 +0000

Alibaba released Qwen 3.8-Max in early August 2026, and its general-availability pricing is now clear. The official Model Studio pricing page lists qwen3.8-max at $2 per 1M input tokens and $6 per 1M output tokens, with one flat tier covering the full 1M-token context window.

Try Apidog today

The flat tier is the key detail: whether you send 5,000 tokens or 900,000 tokens, the input rate remains $2 per 1M tokens.

This guide covers the rate card, caching, free-quota limits, comparisons with Qwen 3.7-Max, Kimi K3, Claude Opus 5, and GPT-5.6 Terra, plus worked cost calculations. For the broader model overview, start with what Qwen 3.8 is and why it matters.

Sticker prices are only an estimate. Qwen 3.8-Max defaults to xhigh reasoning effort, and thinking tokens are billed as output. Measure real requests before forecasting spend. Apidog exposes token usage for each response, making it easier to calculate actual per-task cost.

The GA rate: $2 input, $6 output, one tier

As of August 3, 2026, the official rate card for qwen3.8-max is:

Item	Price per 1M tokens
Input	$2.00
Output, including thinking tokens	$6.00
Cached input, cache hit	10% of the input rate
Explicit cache creation	125% of the input rate
Context tier	One tier: 0 to 1M tokens
Thinking vs. non-thinking	Same rates

Implementation implications:

No long-context surcharge: The 1M-token context window uses one price tier.
Thinking tokens are output: Reasoning increases output token usage and therefore cost.
Maximum output is 65,536 tokens: At $6 per 1M output tokens, a maximum-length response costs about $0.39 in output tokens.

The official Qwen 3.8 announcement describes the model as Alibaba’s most capable model yet, with 2.4T total parameters, 95B active parameters, a 1M-token context window, and multimodal input.

Why flat pricing across 1M tokens matters

Tiered context pricing is common: a vendor charges one rate below a context threshold and a higher rate above it.

Alibaba uses tiered pricing for other models. On the Model Studio pricing page, models such as qwen3-max and qwen3-coder-plus increase per-token pricing as context length grows.

Qwen 3.8-Max instead uses a single 0<Token≤1M tier.

For implementation planning, that makes the cost formula linear:

request_cost =
  (input_tokens / 1_000_000 × $2)
  + (output_tokens / 1_000_000 × $6)

This is especially useful for:

Long-document analysis
Large-codebase agents
Retrieval-heavy RAG pipelines
Workflows that sometimes send hundreds of thousands of tokens

With tiered pricing, an occasional 300K-token retrieval request can enter an expensive bracket. With Qwen 3.8-Max, each input token uses the same rate.

Qwen 3.8-Max vs. Qwen 3.7-Max

Qwen 3.8-Max launched below its predecessor’s list price:

Qwen 3.7-Max: $2.50 input / $7.50 output per 1M tokens
Qwen 3.8-Max: $2.00 input / $6.00 output per 1M tokens

That is a 20% reduction for both input and output.

However, Qwen 3.7-Max is running a 50% promotion:

Qwen 3.7-Max promotional rate: $1.25 input / $3.75 output per 1M tokens

If you do not need Qwen 3.8-Max’s 1M context, multimodal input, or agentic improvements, discounted Qwen 3.7-Max can be a lower-cost choice while the promotion lasts.

For lower-cost workloads, Qwen 3.7-Plus remains a budget option at $0.40 input / $1.60 output, with its own 20% promotion.

Thinking tokens are billed as output

Qwen 3.8-Max supports three reasoning_effort levels:

xhigh
medium
low

The default is xhigh.

In thinking mode, the model generates internal reasoning tokens before returning its final answer. These tokens are billed as output tokens at $6 per 1M tokens.

That means this estimate can be misleading:

cost ≈ prompt tokens + visible response tokens

A visible 800-token answer may include several thousand additional thinking tokens on a difficult task.

Control reasoning cost by task type

Use lower reasoning effort for tasks such as:

Classification
Extraction
Formatting
Simple transformations
Structured-output generation

For example, test multiple effort levels against representative requests:

{
  "model": "qwen3.8-max",
  "messages": [
    {
      "role": "user",
      "content": "Extract the invoice number, total, and due date as JSON."
    }
  ],
  "reasoning_effort": "low"
}

For harder planning, coding, or multi-step analysis tasks, benchmark medium and xhigh rather than assuming that the highest setting is always necessary.

Always inspect the response usage object. Output costs 3× more than input, and reasoning primarily increases output usage.

Context caching: 10% cache hits, 125% creation

Context caching is useful when requests repeatedly include the same prefix, such as:

Long system prompts
Product documentation
Tool definitions
Stable policy instructions
Large reference documents

The pricing is:

Cache hit: 10% of the normal input rate
- $0.20 per 1M cached input tokens instead of $2.00
Explicit cache creation: 125% of the normal input rate
- $2.50 per 1M tokens

The break-even logic is straightforward:

Creating a cache costs an extra 25% once.
Each cache hit saves 90% relative to normal input pricing.
Reusing a prefix twice is already enough for caching to pay off.

Free quota: 1M tokens, Singapore only, 90 days

Model Studio provides a free quota for qwen3.8-max, with important constraints:

Quota: 1M tokens
Region: Singapore only
Expiry: 90 days from activation

Use the Singapore endpoint:

https://dashscope-intl.aliyuncs.com/compatible-mode/v1

The quota does not apply to Beijing or US-Virginia endpoints.

Thinking tokens consume this quota as output tokens, so a small number of difficult xhigh reasoning tasks can use the quota faster than expected.

For all no-cost access options, including Qwen Chat, see how to use Qwen 3.8 for free.

Pricing comparison

List prices per 1M tokens:

Model	Input	Output	Notes
Qwen 3.8-Max	$2.00	$6.00	Flat across 1M context; cache hits at 10%
Qwen 3.7-Max	$2.50	$7.50	Currently 50% off: $1.25/$3.75
Qwen 3.7-Plus	$0.40	$1.60	Currently 20% off
Kimi K3	$3.00	$15.00	Cache hits: $0.30
Claude Opus 5	$5.00	$25.00	—
GPT-5.6 Terra	$2.00	$12.00	—

Key comparisons:

Against Kimi K3: Qwen 3.8-Max costs one-third less on input and 60% less on output. Its cache-hit rate is also lower: $0.20 vs. $0.30. See the Kimi K3 API guide.
Against Claude Opus 5: Qwen is 60% cheaper on input and 76% cheaper on output.
Against GPT-5.6 Terra: Input pricing is the same at $2 per 1M tokens, but Qwen output is half the price.

Price is not a quality benchmark. Test models on your own workload before choosing one based on rate cards alone.

Worked cost examples

Use this formula:

input_cost = input_tokens × 2 / 1_000_000
output_cost = output_tokens × 6 / 1_000_000
total_cost = input_cost + output_cost

Example 1: 50K-token agent session

An agent session uses:

38,000 input tokens for instructions, tool schemas, and tool results
12,000 output tokens

Calculation:

Input: 38,000 × $2 / 1,000,000 = $0.076
Output: 12,000 × $6 / 1,000,000 = $0.072
Total: $0.148

Estimated cost: about $0.15 per session

Now include 8,000 thinking tokens from default xhigh reasoning:

Total output tokens: 12,000 + 8,000 = 20,000
Output: 20,000 × $6 / 1,000,000 = $0.12
Input: $0.076
Total: $0.196

Estimated cost with reasoning: about $0.20 per session

Reasoning increases this example by about 33%.

Example 2: 800K-token document analysis

You provide 800,000 input tokens and request a 5,000-token structured summary:

Input: 800,000 × $2 / 1,000,000 = $1.60
Output: 5,000 × $6 / 1,000,000 = $0.03
Total: $1.63

Estimated cost: about $1.63 per run

The important part is that all 800K input tokens use the same $2-per-1M rate.

Example 3: Cached 100K-token prefix, 50 calls per day

Your application sends 100,000 tokens of system prompt, documentation, and tool definitions on every request.

Without caching:

100,000 × $2 / 1,000,000 = $0.20 per call
$0.20 × 50 calls = $10.00 per day

With explicit caching:

Cache creation:
100,000 × $2.50 / 1,000,000 = $0.25

49 cache hits:
100,000 × $0.20 / 1,000,000 = $0.02 per hit
$0.02 × 49 = $0.98

Daily total:
$0.25 + $0.98 = $1.23

Estimated daily cost: about $1.23 instead of $10.00

That is about an 88% reduction for the repeated prefix.

Build your cost model from measured usage

The calculations above use assumed token counts. Your actual counts will vary, especially when reasoning tokens are enabled.

Use this workflow:

Get an API key.
Configure the appropriate regional endpoint.
Send representative requests for every task type.
Record the response usage object.
Separate input, output, and reasoning-related output usage.
Run multiple tests per task type.
Average usage and apply the $2/$6 rates.

For endpoint setup and protocol options, see the Qwen 3.8 API guide, which covers regional base URLs plus OpenAI-compatible and Anthropic-compatible APIs.

In Apidog, save the regional endpoints as environments and send the same request with each reasoning_effort level. Inspect token usage directly in each response.

A practical test matrix might look like this:

Task type	Tested effort levels	What to measure
Classification	`low`, `medium`	Accuracy, output tokens
Extraction	`low`, `medium`	Schema compliance, output tokens
Coding	`medium`, `xhigh`	Test pass rate, total output
Agent workflows	`medium`, `xhigh`	Tool success rate, total cost
Long-context analysis	`medium`, `xhigh`	Quality, input and output usage

Run at least 10 representative requests for each task type. Then calculate:

monthly_cost =
  average_request_cost
  × requests_per_month

You can also A/B the same prompts against qwen3.7-max or Kimi K3 in one workspace. Download Apidog to capture real per-task token usage while testing.

Bottom line

Qwen 3.8-Max is priced at $2 per 1M input tokens and $6 per 1M output tokens, below Qwen 3.7-Max’s list price and with a flat rate across the full 1M-token context window.

For long-context or high-repetition workloads, the combination of flat input pricing and 10% cache-hit pricing can be compelling.

Before committing to a production cost estimate:

Measure real token usage.
Treat thinking tokens as output costs.
Set reasoning_effort deliberately.
Use caching for repeated prompt prefixes.
Do not build long-term forecasts around time-limited promotions or free quotas.

Frequently asked questions

Does Qwen 3.8 cost more for long prompts?

No. The official pricing shows one tier covering 0 to 1M tokens. A 900K-token prompt uses the same $2-per-1M input rate as a short prompt.

This differs from tiered models, including models listed in Alibaba’s Model Studio model list, where rates can increase with context length.

Do thinking tokens cost extra on Qwen 3.8?

There is no separate thinking-token rate. Thinking and non-thinking requests use the same $2 input / $6 output rates.

However, thinking tokens count as output tokens, and reasoning_effort defaults to xhigh. Reasoning-heavy requests can therefore cost more than the visible answer suggests.

Use lower reasoning effort for simple tasks and inspect the response usage object for actual token counts.

Is there a free way to try Qwen 3.8?

Yes. Model Studio includes a 1M-token free quota valid for 90 days, but only on the Singapore endpoint. Qwen Chat also provides no-cost browser access.

See how to use Qwen 3.8 for free for the available options and limitations.

Is the old “10% preview pricing” still available?

No. The 10% pricing was a July 2026 preview-era promotion. General availability uses the standard $2/$6 rate card. Use the official Model Studio pricing page as the source of truth.

How to Use the Qwen 3.8 API

Hassann — Mon, 03 Aug 2026 04:18:00 +0000

Alibaba released Qwen 3.8-Max in early August 2026, and its hosted API is live on Model Studio. The model provides 2.4T total parameters (95B active), a 1M-token context window, and flat pricing of $2 input / $6 output per million tokens. For model background, see the Qwen 3.8 explainer. This guide focuses on implementation: creating a key, selecting a region, making API calls, streaming responses, and testing both supported protocols.

Try Apidog today

Qwen 3.8-Max supports two protocols from launch:

OpenAI-compatible chat completions and responses endpoints
Anthropic-compatible Messages endpoint

That means existing OpenAI SDK integrations can use the model with a base URL change, while Claude Code can connect through environment variables. You can also test both request formats in Apidog and inspect their streaming behavior.

What you need before you start

Item	Value
Model ID	`qwen3.8-max`
Context window	1,000,000 tokens
Max output	65,536 tokens
Input types	Text and images
Pricing	$2 input / $6 output per 1M tokens, flat across the full context
Reasoning control	`reasoning_effort`: `xhigh` (default), `medium`, `low`
Protocols	OpenAI chat completions + responses, Anthropic Messages
Key environment variable	`DASHSCOPE_API_KEY`

These details come from the official Qwen 3.8 release post and Alibaba Cloud Model Studio documentation. Alibaba promised open weights on Hugging Face and ModelScope for the following week, but as of early August 2026 they were not downloadable. This guide uses the hosted API.

Step 1: Create a Model Studio API key

Open home.qwencloud.com, sign in, and create an API key in the console.

Model Studio still uses the DashScope naming convention internally, so export your key as DASHSCOPE_API_KEY:

export DASHSCOPE_API_KEY="sk-your-key-here"

Store the value in your shell profile, CI secret store, or .env file. Do not commit it to source control.

All examples below read from this environment variable.

New users can test with a free quota of 1M tokens for 90 days. The quota is available only in the Singapore region.

Step 2: Select a regional base URL

The OpenAI-compatible API is available in three regions. Use the endpoint closest to your application servers.

Region	Base URL
Beijing	`https://dashscope.aliyuncs.com/compatible-mode/v1`
Singapore	`https://dashscope-intl.aliyuncs.com/compatible-mode/v1`
US (Virginia)	`https://dashscope-us.aliyuncs.com/compatible-mode/v1`

For most international users, Singapore is the default choice:

https://dashscope-intl.aliyuncs.com/compatible-mode/v1

It is also the endpoint that supports the free quota. The Model Studio model list lists qwen3.8-max for text generation plus image and video understanding.

The examples below use Singapore. Replace the base URL if your workload belongs in Beijing or Virginia.

Step 3: Send your first request

Qwen 3.8-Max supports the OpenAI chat completions format. You can use the official openai Python SDK by setting a DashScope-compatible base URL.

Install the SDK:

pip install openai

Then create a request:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)

completion = client.chat.completions.create(
    model="qwen3.8-max",
    messages=[
        {"role": "system", "content": "You are a precise technical assistant."},
        {
            "role": "user",
            "content": "Explain idempotency in REST APIs in two sentences.",
        },
    ],
)

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

The equivalent cURL request is:

curl https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions \
  -H "Authorization: Bearer $DASHSCOPE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3.8-max",
    "messages": [
      {
        "role": "user",
        "content": "Explain idempotency in REST APIs in two sentences."
      }
    ]
  }'

If you already use an OpenAI-compatible provider, migration is mostly:

Change base_url.
Change the model ID to qwen3.8-max.
Verify provider-specific parameters before production rollout.

The workflow is the same as in the Qwen 3.7 Plus API guide.

Step 4: Stream output and handle reasoning deltas

Qwen 3.8-Max reasons by default. When streaming is enabled, reasoning arrives in reasoning_content deltas before the final answer arrives in normal content deltas.

Your stream consumer should handle both fields:

stream = client.chat.completions.create(
    model="qwen3.8-max",
    messages=[
        {
            "role": "user",
            "content": "Design a rate limiting strategy for a public API.",
        }
    ],
    stream=True,
)

thinking_done = False

for chunk in stream:
    delta = chunk.choices[0].delta
    reasoning = getattr(delta, "reasoning_content", None)

    if reasoning:
        print(reasoning, end="", flush=True)
    elif delta.content:
        if not thinking_done:
            print("\n--- answer ---")
            thinking_done = True

        print(delta.content, end="", flush=True)

Implementation notes:

Reasoning tokens are billed as output tokens.
Reasoning output can increase latency in interactive interfaces.
Do not assume every stream delta contains content.
Persist or display reasoning only if it is appropriate for your product and users.

Step 5: Control `reasoning_effort` and thinking behavior

The API supports three reasoning_effort values:

Value	Typical use
`xhigh`	Hard analysis, agentic coding, complex planning
`medium`	Balanced default for mixed workloads
`low`	Classification, extraction, high-volume simple requests

The default is xhigh.

Qwen also supports:

enable_thinking: enable or disable reasoning
preserve_thinking: preserve reasoning context across turns; enabled by default

Pass these DashScope-specific extensions through extra_body when using the OpenAI SDK:

completion = client.chat.completions.create(
    model="qwen3.8-max",
    messages=[
        {
            "role": "user",
            "content": "Classify this ticket: 'Login page 500s on Safari.'",
        }
    ],
    extra_body={
        "reasoning_effort": "low",
        "enable_thinking": True,
    },
)

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

Thinking-enabled and thinking-disabled requests use the same per-token pricing. The practical cost difference comes from the number of generated reasoning tokens, which is influenced by reasoning_effort.

A useful starting policy:

Use xhigh for coding agents and difficult analysis.
Use low for extraction, routing, classification, and high-volume endpoints.
Use medium while benchmarking uncertain workloads.

Measure output tokens, latency, and quality on your own prompts before selecting a default.

Use the Anthropic-compatible endpoint

Qwen 3.8-Max also exposes an Anthropic-compatible endpoint:

https://dashscope-intl.aliyuncs.com/apps/anthropic

It uses the Anthropic Messages format, allowing tools built for that ecosystem to connect without rewriting clients.

For Claude Code, configure these environment variables:

export ANTHROPIC_BASE_URL=https://dashscope-intl.aliyuncs.com/apps/anthropic
export ANTHROPIC_AUTH_TOKEN=$DASHSCOPE_API_KEY
export ANTHROPIC_MODEL=qwen3.8-max

After exporting them, launch:

claude

Claude Code will run its agentic workflow against Qwen 3.8-Max.

Alibaba used the Claude Code harness for most of its coding benchmarks, so this endpoint is more than a protocol adapter. For coding benchmark details and other supported harnesses, see the Qwen 3.8 for coding breakdown.

Dual protocol support is useful when your tooling is split across OpenAI- and Anthropic-style clients. You can evaluate Qwen without rewriting all clients before testing.

Understand the pricing model

Qwen 3.8-Max pricing is:

$2 per million input tokens
$6 per million output tokens
One flat price tier from 0 to 1M context tokens

There is no long-context surcharge in the listed pricing. Context cache hits reduce repeated input cost to 10% of the normal input price, while explicit cache creation is billed at 125%.

Check the official Model Studio pricing page for current values.

The launch price is lower than Qwen 3.7-Max's listed $2.5/$7.5 pricing. However, do not estimate cost using only visible final-answer tokens: reasoning tokens count as output, and the default effort level is xhigh.

For examples and free-quota details, see the Qwen 3.8 pricing breakdown.

Test and debug Qwen 3.8-Max in Apidog

A multi-region API with two protocols and SSE reasoning streams benefits from saved, repeatable requests. Set up Apidog as an evaluation workspace.

1. Add both protocol shapes

Create one request for the OpenAI-compatible endpoint:

POST /chat/completions

Import an OpenAI-compatible specification if you already have one, then update the server URL.

Add the Anthropic Messages endpoint as a separate request in the same project. Keeping both formats together makes it easier to compare responses and validate migration paths.

2. Model regions as environments

Create environments for:

Beijing
Singapore
US-Virginia

For each environment, define:

base_url
DASHSCOPE_API_KEY

Set base_url to the matching regional endpoint and store the key as a secret. Switching regions then becomes an environment change instead of a request edit.

Use this to compare latency from your deployment location before selecting a production region.

3. Inspect the raw SSE stream

Set streaming in the request body:

{
  "model": "qwen3.8-max",
  "stream": true,
  "messages": [
    {
      "role": "user",
      "content": "Design a rate limiting strategy for a public API."
    }
  ]
}

Inspect the raw server-sent events. You should see:

reasoning_content deltas
content deltas for the final answer

This is useful when a production stream parser fails. Compare the raw provider events with your application's parsed output to isolate whether the issue is in your code or upstream behavior.

4. Compare models with the same prompt

Duplicate a request and change only the model ID:

qwen3.8-max
qwen3.7-max

Run both against the same prompts and record:

Latency
Input and output token counts
Reasoning length
Output quality
Tool or agent success rate

You can also keep a Kimi K3 API request in the same project and compare models using your actual workload rather than vendor benchmark tables.

Download Apidog to build the setup.

FAQ

Is there a free way to try the Qwen 3.8 API?

Yes. New Model Studio accounts receive a 1M-token free quota for qwen3.8-max, valid for 90 days in the Singapore region only.

Route evaluation requests through:

https://dashscope-intl.aliyuncs.com/compatible-mode/v1

Can I run Qwen 3.8 locally instead of using the API?

Not yet, as of early August 2026. Alibaba promised open weights on Hugging Face and ModelScope for the following week, but they were not downloadable at that time.

At 2.4T total parameters, self-hosting would also require a multi-node deployment even with quantization. The hosted API is currently the available option.

Does the Anthropic endpoint support the same features as the OpenAI endpoint?

The Anthropic endpoint uses the Anthropic Messages protocol and is primarily documented for ecosystem tools such as Claude Code.

For direct application integrations, the OpenAI-compatible endpoint is the better-documented path for:

reasoning_effort
enable_thinking
Streaming reasoning_content

How does `qwen3.8-max` compare to Qwen3-Coder for coding?

They target different use cases.

Qwen3-Coder is a specialized coding model line. qwen3.8-max is the general flagship model and posted strong agentic coding results in Alibaba's vendor-run benchmarks, including 86.6 on Terminal Bench 2.1.

Test both with the same prompts, harness, and API settings. The request format is identical apart from the model ID.

Wrap up

Qwen 3.8-Max is straightforward to evaluate:

Create a DASHSCOPE_API_KEY.
Start with the Singapore endpoint and free quota.
Use the OpenAI-compatible endpoint for direct application code.
Stream requests and verify your handling of reasoning_content.
Tune reasoning_effort based on measured latency, token use, and quality.
Use the Anthropic-compatible endpoint when integrating Claude Code or related tooling.

The main operational considerations are reasoning-token output costs, the default xhigh effort level, and the regional restriction on the free quota.

Save both protocols and all regional environments in Apidog so your team can rerun the same evaluation whenever models or pricing change.

DEV Community: Hassann

The Best SoapUI Alternative

Where SoapUI shows its age

The answer: Apidog

What changes in practice

Test logic without the Groovy tax

Mock from the schema instead of scripts

Run performance tests in the same workspace

Add CI without wrestling with Java tooling

Generate documentation from the API contract

SoapUI vs Apidog at a glance

Migrating a SoapUI workflow

1. Start with the API contract

2. Rebuild test cases as scenarios

3. Replace testrunner in CI

Your first hour after switching

Minutes 0–15: Import one service

Minutes 15–30: Rebuild one test case

Minutes 30–45: Make it data-driven

Minutes 45–60: Put it in CI

When SoapUI still makes sense

Frequently asked questions

Is Apidog free like SoapUI Open Source?

Can Apidog test SOAP services?

Do I need to know Groovy to use Apidog?

What replaces SoapUI's testrunner in CI?

What happened to SoapUI Pro?

Try it against one service

The Best ReadMe Alternative

The two problems with docs-only platforms

The platform fee scales like a platform, not like docs

The docs don’t know your API

What the flat fee costs at team scale

The answer: Apidog

What the switch looks like feature by feature

Interactive API reference

Guides and non-reference content

Versioning and environments

The workflow upstream of the docs

ReadMe vs Apidog at a glance

Migrating from ReadMe

When ReadMe still makes sense

Frequently asked questions

Is Apidog really free for API documentation?

Can Apidog docs live on my own domain?

What happens to my ReadMe guides if I switch?

Does Apidog have something like ReadMe’s Ask AI?

How do the docs stay accurate in Apidog?

Publish docs your API can’t drift from

The Best SwaggerHub Alternative

What the new Swagger packaging actually costs

The answer: Apidog

Compare the seat math

Feature-by-feature: Swagger modules vs. Apidog

Studio → visual and code-based spec editing

Portal → hosted API documentation

Functional Testing → unlimited scenarios

Automocking → schema-aware smart mocks

Beyond the modules

SwaggerHub (Swagger) vs. Apidog at a glance

Migrate from SwaggerHub to Apidog

When SwaggerHub still makes sense

Frequently asked questions

What does SwaggerHub cost now?

Is Apidog really unlimited where SwaggerHub is metered?

Can I import SwaggerHub specs into Apidog?

Does Apidog support spec-first design like SwaggerHub?

What about SwaggerHub API gateway integrations?

Design the spec, then run it

The Best Postman Alternative

Why developers are leaving Postman in 2026

What the change costs a real team

The answer: Apidog

Where Apidog goes beyond Postman

One spec drives everything

Testing without run caps or glue code

Mocking with schema-aware responses

Documentation you can publish

Built for AI-assisted development

Postman vs. Apidog at a glance

3. Replace `testrunner` in CI

What replaces SoapUI's `testrunner` in CI?