Discover/Duck API
live

Duck APIduck.ai ↗

Access Duck.ai's AI model catalog, service status, and chat completions via 3 endpoints. Retrieve model capabilities, access tiers, and assistant replies.

Endpoint health
verified 2d ago
get_models
send_chat_message
get_status
3/3 passing latest checkself-healing
Endpoints
3
Updated
17d ago

What is the Duck API?

The Duck.ai API exposes 3 endpoints covering DuckDuckGo's private AI chat service: fetch the full model catalog via get_models, check live service health via get_status, and send a message to any available model via send_chat_message. The get_models endpoint returns structured data across 9 fields per model including provider, capabilities, access tier, supported tools, and file attachment limits by subscription tier.

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

No input parameters required.

→ api.parse.bot/scraper/ec7d8282-525d-433a-9943-342788add371/<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/ec7d8282-525d-433a-9943-342788add371/get_models' \
  -H 'X-API-Key: $PARSE_API_KEY'
All endpoints · 3 totalmissing one? ·

Fetches all available AI models from Duck.ai including their capabilities, providers, access tiers, supported tools, and file type support. Returns structured model data along with a pre-formatted JavaScript export string. No parameters required — returns the full model catalog in a single response.

Input

No input parameters required.

Response
{
  "type": "object",
  "fields": {
    "models": "array of model objects with id, provider, name, capabilities, and access tier info",
    "javascript": "string containing the model data formatted as JavaScript export statements",
    "total_models": "integer count of models returned",
    "attachment_limits": "object with file and image upload limits per subscription tier (free, plus, pro)"
  },
  "sample": {
    "data": {
      "models": [
        {
          "id": "gpt-5.4",
          "name": "GPT-5.4",
          "provider": "openai",
          "modelName": "GPT-5.4",
          "settingId": "261",
          "accessTier": [
            "internal",
            "plus",
            "pro"
          ],
          "modelVariant": null,
          "modelShortName": "GPT-5.4",
          "supportedTools": [
            "WebSearch",
            "SearchResults",
            "RelatedSearchTerms"
          ],
          "entityHasAccess": false,
          "supportedFileTypes": [
            "application/pdf"
          ],
          "supportsImageUpload": true,
          "reasoningEffortAccess": [
            {
              "id": "none",
              "accessTier": [
                "internal",
                "plus",
                "pro"
              ],
              "entityHasAccess": false
            }
          ],
          "supportedReasoningEffort": [
            "none",
            "low",
            "medium"
          ]
        }
      ],
      "javascript": "const duckAIModels = [...];\n\nconst attachmentLimits = {...};\n\nexport { duckAIModels, attachmentLimits };\n",
      "total_models": 8,
      "attachment_limits": {
        "pro": {
          "files": {
            "maxFileSizeMB": 25,
            "maxPagesPerFile": 50,
            "maxPerConversation": 5,
            "maxTotalFileSizeBytes": 26214400
          },
          "images": {
            "maxPerTurn": 3,
            "maxPerConversation": 10,
            "maxInputCharsWithAttachments": 4500
          }
        },
        "free": {
          "files": {
            "maxFileSizeMB": 5,
            "maxPagesPerFile": 15,
            "maxPerConversation": 3,
            "maxTotalFileSizeBytes": 5242880
          },
          "images": {
            "maxPerTurn": 3,
            "maxPerConversation": 5,
            "maxInputCharsWithAttachments": 4500
          }
        },
        "plus": {
          "files": {
            "maxFileSizeMB": 25,
            "maxPagesPerFile": 35,
            "maxPerConversation": 5,
            "maxTotalFileSizeBytes": 26214400
          },
          "images": {
            "maxPerTurn": 3,
            "maxPerConversation": 10,
            "maxInputCharsWithAttachments": 4500
          }
        }
      }
    },
    "status": "success"
  }
}

About the Duck API

Model Catalog

The get_models endpoint returns the complete list of AI models currently available on Duck.ai. Each model object includes an id (used when calling send_chat_message), a provider, a human-readable name, capability flags, and access tier information that reflects which subscription levels can use the model. The response also includes an attachment_limits object breaking down file and image upload limits for free, plus, and pro tiers, plus a javascript string with the same model data pre-formatted as JavaScript export statements — useful for dropping directly into a frontend or config file.

Service Status

The get_status endpoint returns three fields: status (a string where '0' means fully operational), statusV2 (an integer version of the same signal), and secondaryStatus for additional granularity. This is a lightweight health check with no parameters — suitable for polling before making chat calls or surfacing Duck.ai availability in a dashboard.

Chat Completions

The send_chat_message endpoint accepts a required message string and optional model, history, and reasoning_effort parameters. The model parameter should be a valid id from get_models; if omitted, Duck.ai selects a default. Multi-turn context can be passed via the history parameter as a JSON array string of {"role", "content"} objects — each call is otherwise a fresh anonymous session. The response includes the full reply text, a completed boolean confirming the stream ended cleanly, a created Unix timestamp in milliseconds, and requested_model echoing the caller's input alongside the actual model version reported by the provider.

Reliability & maintenanceVerified

The Duck API is a managed, monitored endpoint for duck.ai — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when duck.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 duck.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
2d ago
Latest check
3/3 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
  • Build a model picker UI by reading id, name, provider, and access tier from get_models.
  • Gate chat features behind a Duck.ai health check using the status field from get_status.
  • Run multi-turn conversations by accumulating prior turns and passing them as the history parameter.
  • Select a reasoning depth for supported models by setting reasoning_effort to a value from the model's supportedReasoningEffort list.
  • Compare response latency across models by logging the created timestamp and completed flag per send_chat_message call.
  • Generate a JavaScript model config file automatically using the javascript string returned by get_models.
  • Check attachment_limits before a file upload feature to enforce per-tier restrictions on free vs. pro users.
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 DuckDuckGo provide an official developer API for Duck.ai?+
DuckDuckGo does not publish a documented public developer API for Duck.ai at this time. The service is accessible at https://duck.ai/ as a consumer product.
What does send_chat_message return beyond the reply text?+
In addition to the assistant's full reply string, the response includes: the exact model version that served the reply (model), a completed boolean confirming the stream ended with its terminal marker, a created Unix timestamp in milliseconds, a message_id when the provider supplies one, and requested_model echoing whatever model id the caller passed in.
Does get_models tell me which models support file or image attachments?+
The attachment_limits object in the get_models response specifies per-tier upload limits (free, plus, pro) for files and images, but individual model-level attachment capability flags are part of each model's capability fields in the models array. There is no separate endpoint that lists only attachment-capable models. You can fork this API on Parse and add a filtered endpoint that returns only models where the relevant capability flag is set.
Can I retrieve conversation history or past sessions through this API?+
No stored session retrieval is exposed. Each send_chat_message call is a fresh anonymous conversation; the only way to provide prior context is through the history parameter in the same request. You can fork the API on Parse and revise it to add session storage on top of the existing send_chat_message endpoint.
How current is the model catalog returned by get_models?+
The endpoint reflects whatever models Duck.ai currently lists, so the catalog can change when DuckDuckGo adds, removes, or updates models on the service. There is no versioning or changelog field in the response. The total_models integer is the only count indicator included.
Page content last updated . Spec covers 3 endpoints from duck.ai.
Related APIs in Developer ToolsSee all →