Skip to main content
Static export requires an Enterprise plan.
Use the static export API to programmatically pre-render your site into a self-contained set of static files and download the result as a single bundle. The exported bundle is pure HTML, CSS, and JavaScript with no runtime dependencies, so you can host it on any static file storage or CDN.

​
How static export works

A static export runs as an asynchronous job. You start the job, poll for its status, and then generate a downloadable bundle once the job completes.
1

Start a static export job

Call Start static export job with the domain you want to export. The API queues the job and returns a jobId.
2

Query the job status

Poll Get static export job status with the jobId until status is completed. The response includes live progress and pageCount while the job runs.
3

Generate the bundle

Call Generate export bundle with the jobId. The API packages the export into a single archive and returns bundleUrl, a presigned S3 link to the static export bundle. Download it before the link expires.

​
Feature support by deployment

Which features are available depends on how you host your deployment. Air-gapped deployments have no outbound network access, so anything that relies on Mintlify’s cloud services is unavailable. Features labeled Configurable have different availability depending on your environment’s setup.
FeatureCloudClient-hostedAir-gapped
Documentation searchConfigurable
AI assistantConfigurable
Web analyticsConfigurable
API playground (“Try it”)Configurable
Static export bundle

​
Endpoints

​
Authentication

Authenticate requests with your admin API key. Generate an admin API key on the API keys page in your dashboard. Admin API keys begin with the mint_ prefix and are server-side secrets—do not expose them in client-side code.

​
Deploy the bundle to your Enterprise Helm chart

Self-hosted Mintlify is deployed with the Helm chart in the mintlify/enterprise repository. Once a static export job produces a bundle, you point the chart at the bundle and the deployment serves it from your own infrastructure.
1

Add the bundle reference to your values

Set the static export fields in your values.yaml to the bundleUrl returned by Generate export bundle. The chart fetches the bundle on startup and serves it as the active version.
values.yaml
staticExport:
  enabled: true
  # Presigned S3 link returned by the Generate export bundle endpoint.
  bundleUrl: "https://mintlify-static-exports.s3.amazonaws.com/se_3f9a2c1b8e7d4a06/bundle.tar.gz"
  # Optional: pin to a specific export version for reproducible rollouts.
  version: "2024-06-01"
2

Roll out the chart

Apply the updated values with a helm upgrade. The deployment downloads the bundle, swaps it in as the live site, and serves it from your cluster.
helm upgrade --install mintlify mintlify/enterprise \
  --namespace mintlify \
  --create-namespace \
  -f values.yaml
Because presigned links expire, regenerate the bundle and re-run the upgrade whenever you publish new content or automate the loop with GitHub Actions.

​
Automate with a GitHub Action

The following template workflow runs the full export loop on a schedule or on demand. It starts a job, polls until the export completes, generates a bundle, and rolls the new bundleUrl into the Helm chart.
.github/workflows/static-export.yml
name: Publish static export

on:
  workflow_dispatch:
  schedule:
    - cron: "0 6 * * *" # Daily at 06:00 UTC

jobs:
  export:
    runs-on: ubuntu-latest
    steps:
      - name: Start static export job
        id: start
        run: |
          JOB_ID=$(curl -s -X POST https://api.mintlify.com/v1/static-export/jobs \
            -H "Authorization: Bearer ${{ secrets.MINTLIFY_ADMIN_KEY }}" \
            -H "Content-Type: application/json" \
            -d '{"domain": "docs.example.com"}' | jq -r '.jobId')
          echo "job_id=$JOB_ID" >> "$GITHUB_OUTPUT"

      - name: Wait for the job to complete
        run: |
          for i in $(seq 1 60); do
            STATUS=$(curl -s https://api.mintlify.com/v1/static-export/jobs/${{ steps.start.outputs.job_id }} \
              -H "Authorization: Bearer ${{ secrets.MINTLIFY_ADMIN_KEY }}" | jq -r '.status')
            echo "status=$STATUS"
            [ "$STATUS" = "completed" ] && exit 0
            [ "$STATUS" = "failed" ] && exit 1
            sleep 10
          done
          echo "Timed out waiting for the export job to complete." >&2
          exit 1

      - name: Generate the bundle
        id: bundle
        run: |
          BUNDLE_URL=$(curl -s -X POST \
            https://api.mintlify.com/v1/static-export/jobs/${{ steps.start.outputs.job_id }}/bundle \
            -H "Authorization: Bearer ${{ secrets.MINTLIFY_ADMIN_KEY }}" | jq -r '.bundleUrl')
          echo "bundle_url=$BUNDLE_URL" >> "$GITHUB_OUTPUT"

      - name: Deploy to the Helm chart
        run: |
          helm upgrade --install mintlify mintlify/enterprise \
            --namespace mintlify \
            --set staticExport.enabled=true \
            --set staticExport.bundleUrl="${{ steps.bundle.outputs.bundle_url }}"
Store your admin API key as the MINTLIFY_ADMIN_KEY repository secret, and configure cluster credentials (for example, with azure/setup-helm and your kubeconfig) before the deploy step.

Related topics

Start static export jobGet static export job statusGenerate export bundle