Discover/QwenWork API
live

QwenWork APIqwenwork.ai ↗

Access QwenWork pricing plans, help-center docs, desktop release notes, showcase tasks, and download links via 6 structured endpoints.

Endpoint health
verified 3h ago
get_pricing_plans
list_doc_pages
get_doc_page
list_release_notes
list_showcase_tasks
6/6 passing latest checkself-healing
Endpoints
6
Updated
3h ago

What is the QwenWork API?

The QwenWork API gives developers structured access to six endpoints covering QwenWork's pricing plans, help-center documentation, desktop app release notes, homepage showcase tasks, and installer download links. Use get_pricing_plans to retrieve all individual and organization plan cards with feature bullets and comparison-table rows in a single call, or list_doc_pages to pull the full documentation index grouped by section.

This call costs1 credit / call— charged only on success
Try it

No input parameters required.

→ api.parse.bot/scraper/76a3903d-69be-411b-abb7-d6d2a88efb36/<endpoint>
Ready to send
Fill in the parameters and hit sign in to send to see live response data here.
Call it over HTTPgrab a free API key at signup
curl -X GET 'https://api.parse.bot/scraper/76a3903d-69be-411b-abb7-d6d2a88efb36/get_pricing_plans' \
  -H 'X-API-Key: $PARSE_API_KEY'
Python SDK · recommended

Typed, relational, agent-ready

A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.

  • Fully typed · autocompletes
  • Objects link to objects
  • Typed errors & pagination

Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:

uv add parse-sdk
uv run parse init
uv run parse add --marketplace qwenwork-ai-api

uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.

"""Walkthrough: QwenWork public-site SDK — pricing, docs, showcase, and downloads."""
from parse_apis.qwenwork_ai_api import QwenWork, DocPageNotFound

client = QwenWork()

# Fetch the full pricing page: plans and comparison table.
pricing = client.pricing.get()
for plan in pricing.plans:
    print(plan.name, plan.price, plan.audience)
for row in pricing.comparison:
    print(row.feature, row.values)

# Browse help-center pages, then drill into the first one's full content.
page_summary = client.doc_page_summaries.list(limit=5).first()
if page_summary is not None:
    print(page_summary.section, page_summary.title)
    # Navigate from summary to full page via the typed detail link.
    full_page = page_summary.details()
    print(full_page.title, full_page.headings)
    print(full_page.content_markdown[:200])

# Point-lookup a doc page by a slug discovered above.
if page_summary is not None:
    try:
        doc = client.doc_pages.get(slug=page_summary.slug)
        print(doc.title, doc.description)
    except DocPageNotFound:
        print("page was removed")

# List the latest desktop release notes.
for release in client.releases.list(limit=3):
    print(release.version, release.date)
    for h in release.highlights:
        print(" -", h)

# Browse homepage showcase tasks.
for task in client.showcase_tasks.list(limit=5):
    print(task.use_case_id, task.deliverable_type, task.prompt[:80])

# Check available desktop downloads.
desktop = client.desktop_downloads.get()
print(desktop.requirements)
for link in desktop.downloads:
    print(link.platform, link.url)

print("exercised: pricing.get / doc_page_summaries.list / details / doc_pages.get / releases.list / showcase_tasks.list / desktop_downloads.get")
All endpoints · 6 totalmissing one? ·

Returns every plan shown on the QwenWork pricing page in one call: individual plans (Free, Plus, Pro) and organization plans, each with its displayed price string, price unit, alternate-billing note and feature bullets, plus the individual-plan comparison table as one row per feature keyed by plan name. Prices are the site's displayed USD strings, not numbers. No inputs; a single page fetch.

Input

No input parameters required.

Response
{
  "type": "object",
  "fields": {
    "plans": "array of plan cards: name, audience (individual|organization), price (displayed string), price_unit (nullable), alternate_billing (nullable), features (array of strings)",
    "comparison": "array of feature rows from the individual-plan comparison table: feature label and values keyed by plan name"
  },
  "sample": {
    "data": {
      "plans": [
        {
          "name": "Plus",
          "price": "$20",
          "audience": "individual",
          "features": [
            "Everything in Free, plus:",
            "2,000 credits every month",
            "10 GB cloud storage"
          ],
          "price_unit": "/ month",
          "alternate_billing": "$16 / month billed annually"
        },
        {
          "name": "Enterprise Standard",
          "price": "$30",
          "audience": "organization",
          "features": [
            "2,000 monthly credits per seat",
            "Publish up to 50 pages"
          ],
          "price_unit": "/ seat / month",
          "alternate_billing": "$360 / seat / year"
        }
      ],
      "comparison": [
        {
          "values": {
            "Pro": "4,500",
            "Free": "—",
            "Plus": "2,000"
          },
          "feature": "Monthly credits"
        }
      ]
    },
    "status": "success"
  }
}

About the QwenWork API

Pricing and Plan Data

get_pricing_plans returns every plan card displayed on the QwenWork pricing page — Free, Plus, and Pro for individuals, plus organization plans — each with its name, audience, displayed price string, price_unit, alternate_billing note, and an array of feature bullets. It also returns a comparison array of feature-by-feature rows keyed by plan name, letting you build a comparison table without any client-side restructuring.

Documentation and Release Notes

list_doc_pages returns the complete help-center index as a flat array of pages, each with section, title, slug, description, and url. Pass any slug to get_doc_page to retrieve that page's title, headings array, description, and content_markdown — full body content formatted as markdown. An unrecognized slug returns a 422 error. list_release_notes returns all desktop app release entries newest-first, each with date, version, highlights bullet array, and notes_markdown.

Showcase Tasks and Desktop Downloads

list_showcase_tasks exposes the use-case gallery from the QwenWork homepage: each entry carries a stable use_case_id slug, a deliverable_type label (Web page, Video, Image, and others as the site adds them), and the full prompt text. get_desktop_downloads returns the current installer links per platform — Mac (Apple silicon), Mac (Intel), Windows — alongside the site's stated OS requirements sentence. Installer URLs reflect the latest release advertised on the site at call time.

Reliability & maintenanceVerified

The QwenWork API is a managed, monitored endpoint for qwenwork.ai — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when qwenwork.ai changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.

This isn't an official qwenwork.ai API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.

Last verified
3h ago
Latest check
6/6 endpoints passing
Maintenance
Monitored & self-healing
Will this API break when the source site changes?+
It's built not to. Every endpoint is health-checked on a schedule with automated test probes. When the source site changes and a check fails, the API is automatically queued for repair and re-verified — that's the self-healing layer. Each API page shows when its endpoints were last verified. And because marketplace APIs are shared, any fix reaches everyone using it.
Is this an official API from the source site?+
No — Parse APIs are independent, managed REST wrappers over publicly available data. That is the point: where a site has no official API (or only a limited one), Parse gives you a maintained, monitored endpoint for that data and keeps it working as the site changes — so you get a stable contract over a source that never promised one.
Can I fix or extend this API myself if I need a new endpoint or field?+
Yes — and you don't have to wait on us. This API was generated by the Parse agent, which stays attached. Describe the change in plain English ("add an endpoint that returns reviews", "fix the price field") in the revise box on the API page or via the revise_api MCP tool, and the agent rebuilds it against the live site in minutes. Contributing the change back to the public API is free.
What happens if I call an endpoint that has an issue?+
Errors are machine-readable: a bad call returns a clean status with the list of available endpoints and a repair hint, so an agent (or you) can recover or trigger a fix instead of failing silently. Confirmed failures feed the automatic repair queue.
Common use cases
  • Mirror QwenWork's pricing page in an internal tool by polling get_pricing_plans for plan names, prices, and feature bullets
  • Build a searchable help-center index by loading all page slugs from list_doc_pages and fetching body content via get_doc_page
  • Track QwenWork desktop releases over time by storing version and date fields from list_release_notes
  • Populate a changelog widget by rendering notes_markdown and highlights arrays from list_release_notes
  • Audit QwenWork's AI task coverage by iterating list_showcase_tasks and grouping by deliverable_type
  • Automate distribution of the latest desktop installer URL per platform using get_desktop_downloads
  • Compare individual plan features programmatically using the comparison rows returned by get_pricing_plans
Pricing & limitsSee full pricing →
TierPriceCredits/monthRate limit
Free$0/mo2005 req/min
Hobby$30/mo1,00020 req/min
Developer$100/mo5,000100 req/min
Team$300/mo20,000300 req/min
Company$1,000/mo100,000500 req/min

Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.

Frequently asked questions
Does QwenWork have an official developer API?+
QwenWork does not currently publish a public developer API. The endpoints here expose its pricing, documentation, release notes, and download data as structured JSON.
What does `get_doc_page` return, and what happens with an invalid slug?+
get_doc_page returns the page's title, description, ordered headings array, and full content_markdown. If the slug does not match any page in the documentation index, the endpoint returns a 422 error. Use list_doc_pages first to retrieve valid slugs.
Does the API expose user-account data, workspace activity, or task output from QwenWork?+
Not currently. The API covers publicly available surfaces: pricing plans, help-center documentation, desktop release notes, homepage showcase tasks, and download links. You can fork it on Parse and revise to add an endpoint targeting any additional public page QwenWork publishes.
Are the installer URLs in `get_desktop_downloads` versioned or always the latest?+
The URLs reflect what the QwenWork homepage advertises as the latest release at call time. The API does not maintain a history of past installer URLs; use list_release_notes if you need version history.
Does `list_showcase_tasks` cover all deliverable types QwenWork might add in the future?+
The deliverable_type field is treated as an open set — the API returns whatever labels appear in the homepage gallery at the time of the call. Currently observed values include Web page, Video, and Image, but the set may grow as QwenWork adds new task types. You can fork the API on Parse and revise it to filter or normalize those labels as needed.
Page content last updated . Spec covers 6 endpoints from qwenwork.ai.
Related APIs in Developer ToolsSee all →