> ## Documentation Index
> Fetch the complete documentation index at: https://docs.zenrows.com/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> The Zenrows HTTP API serves Fetch and Extract (extract=auto) at https://api.zenrows.com/v1/, Crawl at https://api.zenrows.com/v1/crawls, and Batch at https://async.api.zenrows.com/v1. Fetch, Extract, Crawl and Batch are described in OpenAPI 3.1 at https://www.zenrows.com/openapi.json and listed in the RFC 9727 API catalog at https://www.zenrows.com/.well-known/api-catalog. Every endpoint also has its own page under /api-reference with its schema. Use the spec for exact parameter names and types. Crawl's endpoints, parameters and errors are also at https://docs.zenrows.com/crawl/endpoints.md. To call Zenrows from an agent, connect the MCP server at https://mcp.zenrows.com/mcp. To search these docs from an agent, connect the docs MCP server at https://docs.zenrows.com/mcp. Agent skills for Zenrows are published at https://github.com/ZenRows/cli and install with `npx skills add ZenRows/cli`.

# Add URLs to an open job

> Valid only when the job is `open` AND its latest run is
`run_sequence == 1` AND `last_batch_received == false`.
Targets the latest (initial) run. Closed jobs and jobs past
their first run reject further adds with 409; a deleted job
is a 404, like every other read of it.

Setting `last_batch: true` closes the job (status → `closed`)
and signals the run to flip to `completed` once tasks drain.

Honors `Idempotency-Key`, scoped to the caller and the job: a
repeat of a call that answered `200` replays that answer, and a
repeat of a call that failed part-way (a `503` after its tasks
were stored, or a lost response) finishes it without adding,
enqueuing or counting any task twice. Without the header every
call appends its tasks.




## OpenAPI

````yaml /api-reference/openapi.json post /jobs/{job_id}/tasks
openapi: 3.1.0
info:
  title: Zenrows API
  version: 1.0.0
  summary: >-
    Reach any page, including the protected web, and return it as HTML,
    Markdown, plaintext, PDF or structured JSON.
  description: >-
    Zenrows is web data infrastructure for agents and applications. Three HTTP
    surfaces are described here:


    - **Fetch and Extract**: one synchronous request per page, at
    `https://api.zenrows.com/v1/`. Authentication is the `apikey` query
    parameter.

    - **Crawl**: collect the URLs behind one start page, at
    `https://api.zenrows.com/v1/crawls`. Authentication is the `X-API-Key`
    header or the `apikey` query parameter.

    - **Batch**: asynchronous jobs of up to 100,000 URLs, at
    `https://async.api.zenrows.com/v1`. Authentication is the `X-API-Key`
    header.


    **Browser** is not described here because it is not HTTP: you connect
    Puppeteer or Playwright to a WebSocket endpoint. See
    https://docs.zenrows.com/browser-sessions/introduction.


    **Cost.** A request costs 1 credit, 5 with JavaScript rendering, 10 with
    premium proxies, 25 with both, and 1 to 25 under `mode=auto`. Failed
    requests are not charged, except target `404` and `410` answers, which are
    billed like a success. The free tier is 5,000 credits a month, no card.


    **Versioning and deprecation.** The version is in the URL path (`/v1`, the
    only version so far). Inside a version Zenrows only adds: new endpoints,
    optional parameters, response fields and headers. Nothing is removed or
    changed. Retiring a version is announced at least twelve months ahead, and
    every response from a deprecated version carries the `Deprecation` (RFC
    9745) and `Sunset` (RFC 8594) headers. Policy:
    https://docs.zenrows.com/api-versioning.


    **Getting a key without a human.** `POST
    https://app.zenrows.com/api/agent/signup` returns a usable key; the spec is
    at https://www.zenrows.com/auth.md and a setup playbook at
    https://www.zenrows.com/SKILL.md.
  termsOfService: https://www.zenrows.com/legal/terms-of-use
  contact:
    name: Zenrows support
    email: support@zenrows.com
    url: https://www.zenrows.com/contact
  license:
    name: Proprietary
    url: https://www.zenrows.com/legal/terms-of-use
servers:
  - url: https://api.zenrows.com/v1
    description: Fetch and Extract (synchronous)
security:
  - apiKeyQuery: []
tags:
  - name: Fetch
    description: Retrieve one page, optionally rendered, proxied, converted or extracted.
  - name: Extract
    description: Which domains Extract serves, and getting a new one prepared.
  - name: Crawl
    description: Collect the URLs behind one start page, and each page's HTML when asked.
  - name: Batch
    description: Submit many URLs as one job and collect the results.
  - name: Account
    description: Plan, credits and concurrency for the calling key.
  - name: Onboarding
    description: Get a working key with no human in the loop.
externalDocs:
  description: Zenrows documentation
  url: https://docs.zenrows.com
paths:
  /jobs/{job_id}/tasks:
    post:
      tags:
        - Batch
      summary: Add URLs to an open job
      description: |
        Valid only when the job is `open` AND its latest run is
        `run_sequence == 1` AND `last_batch_received == false`.
        Targets the latest (initial) run. Closed jobs and jobs past
        their first run reject further adds with 409; a deleted job
        is a 404, like every other read of it.

        Setting `last_batch: true` closes the job (status → `closed`)
        and signals the run to flip to `completed` once tasks drain.

        Honors `Idempotency-Key`, scoped to the caller and the job: a
        repeat of a call that answered `200` replays that answer, and a
        repeat of a call that failed part-way (a `503` after its tasks
        were stored, or a lost response) finishes it without adding,
        enqueuing or counting any task twice. Without the header every
        call appends its tasks.
      operationId: addBatchTasks
      parameters:
        - $ref: '#/components/parameters/BatchJobID'
        - $ref: '#/components/parameters/BatchIdempotencyKey'
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/BatchAddTasksRequest'
      responses:
        '200':
          description: Tasks queued.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BatchAddTasksResponse'
        '400':
          $ref: '#/components/responses/BatchInvalidArgument'
        '401':
          $ref: '#/components/responses/BatchUnauthenticated'
        '402':
          $ref: '#/components/responses/BatchPaymentRequired'
        '403':
          $ref: '#/components/responses/BatchForbidden'
        '404':
          $ref: '#/components/responses/BatchNotFound'
        '409':
          description: |
            Job is not open, last batch already received, or the
            initial run's task ingestion is still in progress (large
            `202`-accepted submissions): in the last case, retry
            once ingest completes.
            Also returned when an `Idempotency-Key` is reused with a
            different body, or while an earlier call with the same key
            is still running (retry shortly).
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/BatchProblem'
        '429':
          $ref: '#/components/responses/BatchQuotaExceeded'
        '503':
          $ref: '#/components/responses/BatchUnavailable'
      security:
        - apiKeyHeader: []
      servers:
        - url: https://async.api.zenrows.com/v1
          description: Batch (asynchronous jobs)
components:
  parameters:
    BatchJobID:
      name: job_id
      in: path
      required: true
      description: Assigned by the server on submit.
      schema:
        type: string
        pattern: ^[0-9A-HJKMNP-TV-Z]{26}$
    BatchIdempotencyKey:
      name: Idempotency-Key
      in: header
      required: false
      description: |
        Optional opaque token scoping a single submit / rerun /
        add-tasks request, kept for 24 hours. A retry with the same
        key and the same body replays the original status and body.
        The same key with a different body, or while the original
        request is still being processed, returns
        `409 idempotency_key_conflict`. A request that is refused
        (any `4xx`, or a `503` before the job or run was created)
        gives the key back, so a retry with the same key is
        processed afresh. A `503` after the job or run was created
        keeps the key: a retry under it is `409`; check the job
        before you resend with a fresh key. On add-tasks a retry
        with the same body finishes an attempt that stopped partway
        and adds each task once. The credit check runs first, so a
        retry of a call that succeeded returns `402` if the account
        has run out of credit since. At most 128 characters; a
        longer key is `400 invalid_argument`.
      schema:
        type: string
        maxLength: 128
  schemas:
    BatchAddTasksRequest:
      type: object
      required:
        - tasks
      properties:
        tasks:
          type: array
          description: |
            1 to 10,000 tasks per call by default (an account can have
            its own limit). An open job's run holds at most 100,000
            tasks in total; going over returns `429 quota_exceeded`.
          minItems: 1
          items:
            $ref: '#/components/schemas/BatchTaskInput'
        last_batch:
          type: boolean
          default: false
          description: |
            Set true on the final batch. Closes the job (status →
            `closed`) and marks the run's `last_batch_received`.
    BatchAddTasksResponse:
      type: object
      required:
        - accepted_tasks
        - job_status
        - latest_run
      properties:
        accepted_tasks:
          type: integer
        job_status:
          $ref: '#/components/schemas/BatchJobStatus'
        latest_run:
          $ref: '#/components/schemas/BatchRun'
    BatchProblem:
      type: object
      description: |
        RFC 7807 Problem Details.
      required:
        - type
        - title
        - status
        - code
      properties:
        type:
          type: string
          format: uri
        title:
          type: string
        status:
          type: integer
        detail:
          type: string
        code:
          type: string
          description: >
            Stable machine-readable error code. Branch on this, not on

            `detail` or `title`. `type` links to the code's entry in the

            public error reference. Codes and their usual status:


            | Status | Codes |

            |---|---|

            | 400 | `invalid_argument` (with `invalid_tasks` for per-task
            problems), `callback_url_must_be_https`,
            `callback_url_unresolvable`, `webhook_signing_requires_active_key` |

            | 401 | `unauthenticated`, `subscription_inactive` (a verified,
            enabled account whose subscription is past due, unpaid, incomplete
            or paused; `detail` stays "Subscription is not active.") |

            | 402 | `payment_required`, `api_key_cap_reached` |

            | 403 | `permission_denied` (the Batch API is not enabled for this
            account) |

            | 404 | `not_found` (job, run, task or export),
            `file_input_not_found` |

            | 409 | `conflict`, `job_not_open`, `last_batch_received`,
            `run_not_terminal`, `run_not_stoppable`, `no_prior_run`,
            `no_matching_tasks`, `run_has_descendants`,
            `idempotency_key_conflict`, `task_not_ready`,
            `partial_rerun_window_expired`, `candidate_pending`, `no_candidate`,
            `file_input_not_uploaded`, `file_input_unsupported_for_job_type` |

            | 410 | `result_expired` (a task's content past the result window,
            or an export past `expires_at`) |

            | 429 | `quota_exceeded` |

            | 500 / 503 | `internal` |


            A failed task's stored `error` uses the scraping engine's

            own codes, plus `gateway_unreachable` (503),

            `gateway_timeout` (504), `gateway_bad_response` and

            `internal` (500) for attempts that failed before the engine

            answered with Problem JSON.


            A path that matches no API route answers a plain `404`

            without a Problem body.


            Clients must accept values not listed here.
        instance:
          type: string
          description: Always `/v1`; it does not name the request path.
        invalid_tasks:
          type: array
          description: Present on validation errors.
          items:
            type: object
            required:
              - index
              - reason
            properties:
              index:
                type: integer
              reason:
                type: string
                x-extensible-enum: true
                description: Clients must accept values not listed here.
                enum:
                  - malformed_url
                  - unsupported_scheme
                  - missing_host
                  - url_too_long
                  - metadata_too_large
                  - metadata_key_invalid
                  - invalid_external_id
                  - unknown_param
                  - invalid_param_value
                  - unsupported_method
                  - body_not_allowed
                  - body_too_large
                  - body_malformed
                  - method_param_conflict
              value:
                type: string
                description: |
                  Offending input. For URL / metadata reasons this is
                  a redacted/truncated form of the bad value. For
                  `unknown_param` / `invalid_param_value` this is the
                  param key.
      additionalProperties: true
    BatchTaskInput:
      type: object
      required:
        - url
      properties:
        external_id:
          type: string
          maxLength: 128
          pattern: ^[A-Za-z0-9._-]+$
          description: |
            Optional caller-supplied correlation id: typically an
            identifier from the caller's own system. Surfaced verbatim
            in result/content responses so callers can match results
            back to their records. **Not required to be unique**:
            callers may reuse the same value across tasks (e.g. when
            multiple scrapes correlate to the same upstream record).
            Independent of the server-
            assigned `task_id`.
        url:
          type: string
          format: uri
          maxLength: 2048
          description: Must be http(s). Other schemes rejected at submit.
        metadata:
          $ref: '#/components/schemas/BatchMetadata'
        method:
          type: string
          enum:
            - GET
            - POST
          default: GET
          description: |
            HTTP method used against `url`. Case-insensitive. POST is
            for **safe/idempotent** requests only (GraphQL queries,
            search endpoints): tasks are retried on transient failures
            and reruns, so the target may see the same POST more than
            once. Don't send a request that must not run twice. POST
            rides the standard (non-headless)
            scraping path: combining it with `js_render`,
            `js_instructions`, or `json_response` is rejected with
            `400 invalid_argument`, the task's `invalid_tasks[].reason`
            being `method_param_conflict`.
        body:
          description: |
            Request body, only with `method: POST`. Any JSON value,
            16 KiB max. An object/array/number/boolean is sent as its
            JSON encoding with `Content-Type: application/json`; a
            string is sent verbatim with
            `Content-Type: application/x-www-form-urlencoded`. Set a
            different target Content-Type via the `custom_headers`
            zenrows param. Never echoed in results listings.
        zenrows_params:
          $ref: '#/components/schemas/BatchScraperParams'
          description: |
            Per-task scraper params. Override the job-level
            `zenrows_params` on key collision (task wins).
    BatchJobStatus:
      type: string
      x-extensible-enum: true
      enum:
        - open
        - closed
        - deleted
      description: |
        - `open`: initial run still accepting `addBatchTasks`. Only
          meaningful while `latest_run.run_sequence == 1`.
        - `closed`: no more tasks accepted (created closed, or
          closed via `/close` / `addTasks{last_batch}` / `/rerun`).
        - `deleted`: never returned. A deleted job disappears from
          every read and list the moment `DELETE` is accepted (reads
          answer 404); its data is cleaned up asynchronously after.

        Clients must accept values not listed here.
    BatchRun:
      type: object
      required:
        - run_id
        - job_id
        - run_sequence
        - status
        - stats
        - created_at
        - updated_at
      properties:
        run_id:
          type: string
        job_id:
          type: string
        run_sequence:
          type: integer
          minimum: 1
        status:
          $ref: '#/components/schemas/BatchRunStatus'
        trigger:
          $ref: '#/components/schemas/BatchRunTrigger'
        stats:
          $ref: '#/components/schemas/BatchRunStats'
        last_batch_received:
          type: boolean
          description: |
            Meaningful only for the initial run of an open job.
            Once true, `addBatchTasks` is rejected and the run drains
            into `completed`.
        pause_state:
          type: string
          enum:
            - active
            - paused
          description: |
            Reversible-suspend flag, orthogonal to `status`. A run
            never paused omits it; a resumed run returns `active`
            explicitly. Treat a missing field as `active`. Flip via
            `POST /jobs/{id}/pause` and `/resume`.
        ingest_status:
          type: string
          x-extensible-enum: true
          enum:
            - pending
            - done
          description: |
            Present only on runs created by a large (202) submission
            or a large (202) rerun. `pending`: task rows are still
            streaming into storage; reads may return partial pages
            and `addBatchTasks` returns `409`. `done`: every accepted
            task row is visible. Omitted on runs whose tasks were
            written on the request path (201 submissions and
            reruns, `addBatchTasks` batches).

            Clients must accept values not listed here.
        created_at:
          type: string
          format: date-time
        updated_at:
          type: string
          format: date-time
        failure_reason:
          type: string
          x-extensible-enum: true
          enum:
            - insufficient_credits
            - subscription_inactive
            - api_key_cap_reached
          description: |
            Present only when `status == failed`: the account-level
            cause of the auto-fail. Omitted otherwise. Distinct from
            `stats.failure_reasons` (the per-task rollup).
            - `insufficient_credits`: the account is out of credits, or
              the plan doesn't include a feature the task needs.
            - `subscription_inactive`: the subscription is not active
              or has expired, the plan doesn't include the API, or the
              job's API key is no longer valid.
            - `api_key_cap_reached`: the job's API key reached one of
              its credit caps (day, week, month or billing period).
              Resolves on its own when that cap's window resets, or
              when the cap is raised.

            Clients must accept values not listed here.
        failure_detail:
          type: string
          description: |
            Human-readable explanation of `failure_reason`, e.g. which
            cap was reached and when it resets. Present only when
            `failure_reason` is. At most 500 characters (Unicode code
            points); longer upstream text is cut. Free text for display:
            branch on `failure_reason`, never on this string.
          example: Subscription has no credit available.
    BatchMetadata:
      type: object
      description: Opaque user-supplied key/value pairs. Stored on the task; not forwarded.
      additionalProperties:
        type: string
        maxLength: 1024
      maxProperties: 20
    BatchScraperParams:
      type: object
      description: |
        Subset of the Fetch parameters
        (https://docs.zenrows.com/fetch/api-reference).
        The API pins the surface to a known set: unknown keys are
        rejected with `400 invalid_argument` (`unknown_param`). The
        `screenshot*` family is deliberately excluded; `mode` accepts
        `"auto"` only for now.

        Each value can be any JSON scalar (string, boolean, integral
        number); the API stores it as a string.

        Per-task `zenrows_params` override job-level `zenrows_params`
        on key collision.

        Supported keys: `mode`, `js_render`, `js_instructions`,
        `custom_headers`, `premium_proxy`, `proxy_country`,
        `session_id`, `original_status`, `allowed_status_codes`,
        `wait_for`, `wait`, `block_resources`, `json_response`,
        `css_extractor`, `autoparse`, `extract`, `extract_fields`,
        `response_type`, `outputs`.

        `extract` selects the structured-extraction contract family
        (`auto`, `native`, or `standard`); `extract_fields` optionally
        narrows the returned fields. Extract works on any domain
        Zenrows has prepared, with any active API key; a task against a
        domain that isn't prepared yet fails with the scraper API's
        403 `REQS007`.

        `custom_headers` additionally accepts an object of header
        name → value pairs (or that object serialised as a JSON
        string), e.g. `{"custom_headers": {"Referer":
        "https://www.google.com/"}}`. The headers are forwarded to
        the scraping target, subject to the scraper API's usual
        header sanitisation. At most 32 headers / 8 KB serialised;
        names must be valid HTTP tokens. Header filtering and
        browser-header sanitisation follow the same rules as a
        single Fetch request.
        A task-level
        `custom_headers` replaces the job-level object wholesale:
        no per-name merging.
      additionalProperties:
        oneOf:
          - type: string
          - type: boolean
          - type: integer
          - type: object
            additionalProperties:
              type: string
    BatchRunStatus:
      type: string
      x-extensible-enum: true
      enum:
        - running
        - pending
        - completed
        - stopped
        - failed
        - deleted
      description: |
        In-flight:
        - `running`: work queued / in flight.
        - `pending`: initial run of an open job, idle between batches.

        Terminal:
        - `completed`: natural finish.
        - `stopped`: caller called `POST /jobs/{id}/stop`. No new
          tasks are picked up; in-flight tasks may still finish.
          Result bodies are kept. `stats.completed < stats.total`
          signals "stopped early".
        - `failed`: the run was auto-failed on an account-level error
          (insufficient credits / inactive subscription / the API key's
          credit cap reached). No new tasks are picked up;
          `failure_reason` and `failure_detail` carry the cause.
          Re-runnable once the account or cap is resolved. Result bodies already produced
          are kept.
        - `deleted`: caller called
          `DELETE /v1/jobs/{id}/runs/{run_id}`. The run's result
          bodies and data are being deleted; once complete the run
          disappears.

        Clients must accept values not listed here.
    BatchRunTrigger:
      type: string
      x-extensible-enum: true
      enum:
        - manual
        - scheduled
      description: |
        What set this run in motion. Always set.
        - `manual`: caller-initiated: `POST /jobs`, `POST /jobs/{id}/rerun`
          (any job type, full or `?status=`-filtered, manual fire of
          a scheduled job).
        - `scheduled`: automatic, fired by the configured
          schedule (recurring or one-shot).

        Clients must accept values not listed here.
    BatchRunStats:
      type: object
      required:
        - total
        - completed
        - successful
        - failed
      properties:
        total:
          type: integer
          description: Number of tasks in this run.
        completed:
          type: integer
          description: successful + failed.
        successful:
          type: integer
        failed:
          type: integer
        failure_reasons:
          type: object
          description: |
            Coarse rollup of terminal failures keyed by a small public
            taxonomy. Lets you answer "what kinds of failures did I
            get?" without paging every error blob. Best-effort,
            indicative: omitted on runs with no failures yet and on
            runs that predate the feature.

            Vocabulary (the only keys that appear):
            - `auth_failed`: credentials or billing
            - `blocked`: anti-bot / policy denials, including a bot wall
              Extract met on the fetched page
            - `bad_target`: target URL is the problem (bad host, 404, 410,
              too large, or a page Extract does not cover or found no data on)
            - `rate_limited`: target throttled the request
            - `timeout`: the scrape didn't complete in time
            - `gateway_error`: Zenrows-side transport / 5xx
            - `other`: anything else
          additionalProperties:
            type: integer
            minimum: 0
          example:
            blocked: 9
            gateway_error: 4
        spend:
          allOf:
            - $ref: '#/components/schemas/BatchSpend'
          description: |
            Indicative spend summed across every task attempt in
            this run. Absent on runs whose tasks predate this
            field (treat as zero).
    BatchSpend:
      type: object
      description: |
        Indicative `{credits, cost}` pair: what was charged for
        the scoped work. **Not billing-grade**; your account
        statement is authoritative. Use as a "how much did this
        cost?" indicator, not for reconciliation.
      required:
        - credits
        - cost
      properties:
        credits:
          type: integer
          minimum: 0
        cost:
          type: number
          format: double
          minimum: 0
  responses:
    BatchInvalidArgument:
      description: Request validation failed.
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/BatchProblem'
    BatchUnauthenticated:
      description: Missing / invalid API key.
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/BatchProblem'
    BatchPaymentRequired:
      description: |
        The run cannot start because of billing. The problem `code`
        tells the cases apart:
        - `payment_required`: the subscription has expired, has no
          credit available, or its plan does not include the API
          ("Subscription does not allow access to this service.").
        - `api_key_cap_reached`: this API key reached one of its
          credit caps. `detail` names the window, the cap and when it
          resets (UTC). Other keys on the account are unaffected.

        Clients must accept `code` values not listed here.
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/BatchProblem'
    BatchForbidden:
      description: |
        `permission_denied`: the Batch API is not enabled for this
        account. Any `/v1` route can return it.
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/BatchProblem'
    BatchNotFound:
      description: Resource not found (or not owned by caller).
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/BatchProblem'
    BatchQuotaExceeded:
      description: >
        `quota_exceeded`: an account cap is reached. On submit: the

        account already has its maximum of active regular jobs (3 by

        default, Crawl jobs included; an open job counts until it is closed) or
        of

        scheduled jobs (5 by default). On add-tasks: the open job's

        run would go over 100,000 tasks. For a job cap, finish, close

        or delete a job, then retry; for the task cap, send fewer

        tasks or close the job. A refused submit gives its

        `Idempotency-Key` back, so the retry can reuse it; an

        add-tasks retry with the same body is checked again. No

        `Retry-After` is sent: the cap clears when a job finishes or

        is deleted, not with time.
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/BatchProblem'
    BatchUnavailable:
      description: Transient upstream failure; safe to retry.
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/BatchProblem'
  securitySchemes:
    apiKeyQuery:
      type: apiKey
      in: query
      name: apikey
      description: >-
        Fetch, Extract, Crawl and the account endpoint accept the key as the
        `apikey` query parameter. Keys are per account and self-serve: create
        one in the Zenrows dashboard (app.zenrows.com), or, for an agent with no
        human present, `POST https://app.zenrows.com/api/agent/signup`.
    apiKeyHeader:
      type: apiKey
      in: header
      name: X-API-Key
      description: >-
        Batch, Crawl, the Extract endpoints and the account endpoint read the
        same key from the `X-API-Key` header.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.