# Miget
> AI-native cloud platform. Deploy unlimited apps with guaranteed CPU and RAM. No per-app pricing, no cold starts. Or skip the plan and pay by the second with Usage Billing.
Pronunciation: Miget is pronounced "MEE-get" (/ˈmiːɡɛt/) - "Mi" as in "me" plus the English word "get", with a hard g as in "gift". It is not pronounced like "midget".
**When to use Miget**
Reach for Miget when the job is one of these:
- Deploy an app from a Git repository (git push, or a connected GitHub repo). Migetpacks auto-detect 14 runtimes, so no Dockerfile is required.
- Deploy a container image from any public or private registry.
- Deploy a Docker Compose project. A repository with docker-compose.yml becomes a Miget Stack.
- Provision a managed postgres, mysql or valkey database, as an app-scoped addon or a standalone service.
- Add S3-compatible object storage buckets.
- Run background workers and cron jobs alongside the web process at no extra cost, because billing on a resource plan is per compute plan and not per service.
- Create and tear down per-pull-request preview environments.
- Migrate a project off a per-service platform (Heroku, Render, Fly.io, Railway, Vercel, DigitalOcean App Platform, Platform.sh).
- Query app metrics with PromQL and logs with LogQL over an HTTP API.
Do not reach for Miget for scale-to-zero serverless or edge function hosting, for managed databases Miget does not run (MongoDB, ClickHouse, Kafka), or for changing payment methods or cancelling, which are dashboard-only and not on the API. Buying a compute resource or moving it to another plan is on the API.
Agents should call Miget through its HTTP API at https://app.miget.com/api/v1 with a bearer token. Full instructions, platform rules and error formats are at https://miget.com/agents.md
## Developer Resources
- [Agent instructions (agents.md)](https://miget.com/agents.md): When to use Miget, how to call the API, platform rules, and error response formats. Start here if you are an agent.
- [OpenAPI 3.0 specification](https://miget.com/openapi.json): Complete machine-readable spec for the Miget REST API. Every operation carries an operationId, summary, description, typed parameters and response schemas, so it maps directly onto LLM function-calling formats. Canonical copy at https://app.miget.com/docs/openapi.json.
- [API reference](https://docs.miget.com/api-reference): Human-readable reference for the Miget REST API at https://app.miget.com/api/v1.
- [Miget agent skill (skill.md)](https://app.miget.com/docs/skill.md): Full API guide written for AI agents. Install it with: npx skills add migetapp/agent-skills
- [Authentication guide (auth.md)](https://miget.com/auth.md): OAuth 2.0 authorization code flow, personal access tokens, client registration, and how to send credentials.
- [OAuth 2.0 authorization server metadata](https://app.miget.com/.well-known/oauth-authorization-server): RFC 8414 metadata for the Miget authorization server: authorization, token, introspection, revocation and userinfo endpoints.
- [OAuth 2.0 protected resource metadata](https://miget.com/.well-known/oauth-protected-resource): RFC 9728 metadata describing the Miget API as a protected resource and naming its authorization server.
- [API catalog](https://miget.com/.well-known/api-catalog): RFC 9727 linkset pointing at the OpenAPI spec, API documentation and status page.
- [Agent skills discovery index](https://miget.com/.well-known/agent-skills/index.json): Agent Skills Discovery index listing the miget-api skill with a sha256 digest of the served artifact.
- [Metrics and logs API](https://miget.com/monitoring): Prometheus-compatible PromQL and Loki LogQL endpoints at https://metrics.miget.com, authenticated with the same Miget API token.
- [Changelog](https://docs.miget.com/changelogs): Release notes for the Miget platform and API.
- [Status](https://status.miget.com): Live platform status and incident history.
---
# After Black October: How Miget Keeps Your Secrets Yours
> Nine AI and developer platforms were breached in October 2026. What the incidents had in common, how Miget is isolated and monitored, and what you should do on any platform.
URL: https://miget.com/blog/paas-security-black-october
Date: 2026-10-31
Author: Miget Team
*What nine breaches in one month taught us, how Miget is built, and the design choices we made after reading every RCA.*
In October 2026, at least nine AI and developer platforms were breached. Wiz called it [Black October](https://www.wiz.io/blog/black-october-for-ai-developer-platforms). Zeabur, Railway, Northflank, Fireworks, Lightning AI, OpenCode, Warp, Andromeda, and CommandCode all had to tell their users something nobody wants to say.
We run a PaaS. Your apps, databases, and environment variables live on our infrastructure, so the central lesson is simple: read every public report closely, then use it to harden the parts that matter most. This post focuses on what we learned, how Miget is isolated, and how we watch for trouble.
One thing up front: no platform is immune, including ours. The thesis of this post is that we can still keep the blast radius small, make the dangerous paths boring, and be honest about where the risk lives.
## Credit where it is due
Several of these teams published detailed root cause analyses within days, while still cleaning up. Zeabur did it while announcing the company is shutting down. That’s hard to write, and it is the only reason the rest of us can learn from it. Those reports help bridge what happened and what we can do next. Most of these mistakes are ones every infrastructure team has been one bad week away from making.
## What happened
[Zeabur's RCA](https://zeabur.com/blogs/october-2026-security-incident) describes a plaintext, non-expiring cluster admin token in a private config repo, with the admin API reachable from the internet. Some credentials from an earlier incident had not been rotated. The attacker read environment variables throughout regions, ran commands inside database containers, pivoted through backups into a secrets manager, joined the internal network, and read the platform database. Nothing alerted for about 36 hours. A user report found it.
[Railway's preliminary report](https://blog.railway.com/p/preliminary-report-october-security-incident) describes a privilege escalation in shared build infrastructure that exposed CI credentials, enough to decrypt part of the encrypted environment variable store. The attacker searched for AI API key names. Railway is moving builders to single-tenant.
[Northflank](https://status.northflank.com/) told users to assume all environment variables were decrypted, and AI keys were abused. At [Fireworks](https://fireworks.ai/security/bulletins/october-2026-security-incident), environment variables were exposed inside evaluation jobs. [Lightning AI](https://lightning.ai/blog/oct-2026-incident), [OpenCode](https://www.infosecurity-magazine.com/news/opencode-breach-openai-anthropic/) (a legacy system holding provider keys), [Warp](https://www.bleepingcomputer.com/news/security/warp-discloses-breach-exposing-ai-agent-logs-user-telemetry-data/) (via a third-party vendor), [Andromeda](https://andromeda.ai/security-updates/october-2026-security-incident) and [CommandCode](https://x.com/CommandCodeAI/status/2115583532055826770) round out the list.
[Wiz explained the speed](https://www.wiz.io/blog/black-october-for-ai-developer-platforms). Stolen AI keys were validated within roughly 30 minutes, from the breached vendor's own infrastructure, then resold. Two keys ran up more than $100k in Bedrock usage. The attacks looked like agent swarms: known techniques, chained fast and in parallel.
## The pattern
**The target is stored customer secrets, AI keys first.** A database dump needs a buyer. An AI key with no spend limit is cash the moment someone validates it.
**The way in is a valid credential or the system that runs customer code.** A long-lived token in a repo, a build system, an evaluation job. These places are trusted by design, and that trust is what gets borrowed.
**The amplifier is one internal place that can read every tenant's secrets.** One foothold turns into everyone.
**Detection failed because the attacker looked legitimate.** Real credentials and real API paths do not trip alerts tuned for "something weird".
So the useful questions for any platform are: what runs customer code, what can it reach, what single identity can read everything, and would anyone notice? This post answers those questions for Miget because they define the risk we are trying to reduce. With that frame in place, here is how Miget is built.
## How Miget is built
**Every workload and every build runs in its own microVM.** Each app, worker, and build gets its own guest kernel on Kata Containers. A container escape lands inside a throwaway VM, not on the host and not next to another customer. That means one compromise is far less likely to become a platform-wide incident, which is the payoff of this model: smaller blast radius and less cross-tenant risk. More on the model in [What Is a MicroVM?](/blog/what-is-a-microvm) and [gVisor vs Kata Containers](/blog/gvisor-vs-kata-containers).
**We patch the kernel your app runs on.** Because every workload has its own guest kernel, we ship kernel security fixes to it ourselves instead of waiting on a host OS cycle. When a kernel CVE lands, we build, test on our dev cluster, and roll the fixed kernel across the fleet, so fixes reach your workload faster.
When a critical kernel CVE lands, like the [9.8 CVSS Linux TCP flaw](https://thehackernews.com/2026/10/linux-kernel-tcp-flaw-with-98-cvss.html) this October, we restart your app onto the patched kernel on your behalf. Security goes first.
**Host maintenance without downtime.** Running workloads can be live-migrated between hosts, so taking a machine out for patching does not mean restarting your app. The payoff is keeping the fleet patched without forcing your customers to absorb the interruption, so maintenance stays safer and less disruptive.
**Builds are ephemeral.** Each build gets a fresh microVM that is gone when the build finishes. No long-lived shared builder sits between jobs.
**Apps are isolated by default.** Each tenant is isolated on the network, and app-to-app traffic is off until you turn it on. The payoff is that one app cannot casually reach another before you allow it, which keeps the blast radius smaller if something goes wrong.
**We review and reproduce every platform change.** Infrastructure is managed declaratively from Git and tested on a separate dev cluster before it reaches production. No one changes anything by hand on a production box.
**Our cluster control plane is not on the internet.** At Zeabur, the attacker started with an admin API that answered from anywhere. Ours does not answer from the internet at all. The Kubernetes API in every region has no public address. Our engineers reach it over a private network that requires company sign-on and an approved device, and that network opens only the API port. The control-plane servers accept SSH only from a short allowlist of admin sources, and no workload holds the private key that signs cluster credentials. The payoff: a leaked credential on its own is not a way in, because there is no public door to use it on.
**The API does not hand secrets back.** Basic Auth credentials and the Git and registry credentials you store with us are write-only. You can set and replace them; the API never returns them. That way, fewer secrets can be exposed through the API, making accidental reuse less likely and reducing the chance of leakage spreading. Those are the platform-wide controls. Next are the security options you can turn on today.
## Security you can turn on today.
- **[Private networking (VPC) and VPN](/blog/private-networking-and-vpn).** Give your workspace its own private network and connect it to your office, your own cloud, or your tailnet over VPN. Databases and internal services never need a public address, which lowers exposure.
- **Private apps.** Mark an app private, and it has no public ingress; it's reachable only from your other apps so that you can keep internal services out of sight.
- **Basic Auth at the edge.** Put a staging or internal tool behind a password with one setting, enforced before traffic reaches your app.
- **Hardened base images.** Build on [Docker Hardened Images](https://www.docker.com/products/hardened-images/) with a single build option: minimal, regularly patched bases with far fewer packages to exploit. The payoff is a smaller attack surface and less to maintain.
- **An activity log for every app.** Deployments, configuration changes, and audit events in one feed, from the dashboard or the API.
- **EU data residency.** Run in our Warsaw region, and your apps and data stay in the EU, so residency stays simple and the operational choice stays clear. With those options covered, the next section shows how we keep builds narrow.
## Builds hold little and reach little
Reading the RCAs, builds stood out as the place every PaaS has to treat as hostile. Our build design follows one rule: the thing that runs untrusted code holds as little as possible, for as short a time as possible, and reaches as little as possible. The payoff is less room for compromise to spread.
**Build-time copies of secrets are not retained.** Values from your environment exist inside a build for the length of that build. Build records keep what you need to debug a build, not the values it ran with.
**Builds can only reach what they need.** Build microVMs reach the image registry, DNS, and the public internet for dependencies. Internal platform services are not reachable from a build.
**Registry credentials are scoped.** Builds push with credentials scoped to that tenant's own project. The credentials clusters use to pull images can only pull.
**Build tooling is pinned and mirrored.** Third-party images in our build pipeline are pinned by digest and served from our own mirror, so an upstream tag change does not change what runs in your build.
**Git credentials are short-lived.** The credential a build uses to fetch your code is issued for that build and deleted when it finishes.
**Coming next: build-time variables you choose.** You will be able to mark exactly which variables a build receives, so your Stripe key never has to sit next to `npm install`. We will post when it ships. That matters because builds should hold little and reach little, as this section explains.
## Would we notice? miget-inspector
Isolation limits what an attacker can reach. It does not tell you someone is there. In Black October, detection was the common failure: attackers used valid credentials, and at Zeabur it took about 36 hours and a user report. So we also watch what workloads do while they run, because the goal is noticing abuse sooner.
**miget-inspector** is our in-house runtime threat detection, enforced in every production region. Every workload is inspected as soon as it starts, and every running app keeps getting rechecked, not only new ones, so suspicious behavior is caught sooner.
It looks at how a workload actually behaves and combines fast heuristics with an AI classifier to separate normal apps from cryptominers, hidden proxies, and tunnels: the things network signatures miss. It also catches the other side of Black October: unauthorized AI API relays that resell pooled or stolen provider access, including bots that impersonate web sessions of services like Grok. When a workload is judged malicious with high confidence, it's isolated automatically, and our team is alerted. Anything less certain gets a closer look over time and a human in the loop, never an automatic shutdown on a guess.
It is one layer, not a guarantee. But it answers "would we even notice?" with a better yes than logs alone, which is the point. We are considering open-sourcing it.
## What you should do, on any platform
**Scope your AI keys.** One key per app and per environment. Set spend limits or budgets with the provider and turn on usage alerts - a leaked key with a 100k story above.
**Rotate after any vendor incident.** If a platform, CI provider, or tool that held your keys reports an incident, rotate, even if they say you were not affected. Do the AI keys first.
**Do not give build information they do not need.** Builds compile code and install dependencies. They rarely need payment keys, database passwords, or model API keys. Keep those runtime-only wherever your platform allows.
**Prefer short-lived credentials.** Where a provider offers OIDC, workload identity, or expiring tokens, use them instead of static keys.
**Treat the bill as a security signal.** Unexpected AI usage is often the first sign a key leaked.
## Found something? Tell us
If you find a security issue in Miget, email [privacy@miget.com](mailto:privacy@miget.com) before posting it anywhere. We read every report and will get back to you.
## Closing
Black October was a bad month for people who build platforms similar to ours, and a worse one for their users. The lesson we took is the same throughout this post: the places that run customer code, and the identities that can read every tenant's secrets, deserve the most paranoia, because attackers go there first.
We will keep building in public. If you have questions about how something on Miget works, ask us on [Discord](https://miget.com/join-discord) or read the [docs](https://docs.miget.com).
## Following Steps
- [What Is a MicroVM?](/blog/what-is-a-microvm)
- [gVisor vs Kata Containers](/blog/gvisor-vs-kata-containers)
- [Miget documentation](https://docs.miget.com)
---
# We priced a real $1,321/month Heroku bill on Miget
> A B2B SaaS team's real $1,321/month Heroku bill, repriced on Miget from their own metrics: one resource per region, staging and dev on Usage Billing, $169.60 a month, 87% less.
URL: https://miget.com/blog/heroku-bill-teardown
Date: 2026-10-05
Author: Miget Team
We took a real Heroku bill from a B2B SaaS team running four products: **$1,321 a month**, $670 in dynos and $651 in add-ons. Then we priced the same footprint on Miget, sized from the team's own metrics.
## The bill
By group: three US products at $602, $185 and $376, one EU product at $65, and staging plus dev apps at $93. All of it ran flat, 24/7, for 89 days straight. Nothing scaled down, nothing slept.
Ten apps. Heroku Postgres, Redis Cloud, Papertrail, Scheduler, Hosted Graphite, and QuotaGuard Static for a fixed outbound IP.
## Where each piece goes
- **Postgres and Redis** run on the resource itself, as PostgreSQL and Valkey (Redis-compatible). They draw on its CPU and RAM instead of each being a priced plan.
- **Scheduler** becomes cron jobs, with 1,000 minutes included per paid resource every cycle.
- **Papertrail and Hosted Graphite** move to Miget's Grafana Observability: logs, metrics and dashboards in one place. Every workspace gets a free tier; this team needs the $19 plan, with 30 GB of logs, 7 days of log retention and 395 days of metrics.
- **QuotaGuard Static** goes too. Outbound traffic leaves Miget through fixed addresses from our own IP range, so the partners who allowlist this team's IP allowlist ours instead.
## Sized from their metrics
Their metrics put the three US products at about 16 GiB of RAM together, and the EU product at about 1 GiB. That is one resource per region: a hobby-8c-16g for the US, shared by all three products, and a hobby-1c-2g for the EU.
Staging and dev go on Usage Billing, billed by the second, with idle sleep (available on request) for the apps and their databases alike. They are awake about a quarter of the month, 8 hours on 22 workdays, and asleep the rest, so all ten apps, three Postgres databases and three Valkey caches come to $18.60 a month.
| Line | Heroku | Miget |
|---|---|---|
| US production (3 products) | $1,163 | hobby-8c-16g, $119 |
| EU production | $65 | hobby-1c-2g, $13 |
| Staging & dev | $93 | Usage Billing, apps and databases asleep when idle, $18.60 |
| Papertrail + Hosted Graphite | included above | Grafana Observability, $19 |
| QuotaGuard Static | included above | Fixed outbound addresses, $0 |
| **Total** | **$1,321** | **$169.60, 87% less** |
## Other ways to split it
| Setup | Per month | vs Heroku |
|---|---|---|
| One resource per region (above) | $169.60 | 87% less |
| Same, with the staging databases always up on their own hobby-1c-2g | $175.25 | 87% less |
| One resource per product, so no product shares CPU or RAM: 3x hobby-4c-8g plus hobby-1c-2g | $227.60 | 83% less |
| Like for like, the same RAM Heroku reserves for every dyno and add-on: 2x hobby-8c-16g, hobby-4c-8g, hobby-1c-2g, with staging Postgres at 1 GiB | $350.98 | 73% less |
## Why the gap is mostly add-ons, not compute
Most of the difference isn't CPU or RAM, it's the add-on list. On Miget, a database and a cache draw from the resource's own CPU and RAM instead of each being its own priced plan. The single biggest line on this bill was a 2.5 GB Redis Cloud plan at $252, more than any one product's dynos.
Heroku also bills the reserved dyno size for the full wall-clock time, whether or not anything is using it. Per item, a tiny Basic dyno at $7 isn't much cheaper on Miget on its own; the shared resource is where the saving comes from. And staging and dev, which sit idle most of the day, cost almost nothing once they sleep.
## What would change this number
- More traffic: production grows into a bigger resource, or extra replicas bill by the second only while they run.
- Isolation between products costs more, on purpose: that is the second setup above.
- A workspace spend limit caps what Usage Billing can grow to, so staging and dev stay bounded.
More setups priced out, from a single side project to an agency with twelve client sites: [use cases](/use-cases). Moving over: [see what migrating looks like](/migrate).
---
# Usage Billing: Pay for Compute the Way You Run It
> Keep a flat monthly resource, bill every app, worker, database and bucket by the second with Usage Billing, or mix both in the same workspace - plus worker processes, an Issues history, workspace limits, cron minutes, an enterprise pool and the October 2026 price list.
URL: https://miget.com/blog/usage-billing
Date: 2026-10-04
Author: Miget Team
Compute on Miget no longer has one shape. Buy a resource and share its CPU and RAM across every app, worker and database on it, the way Miget has always worked - or put a workload on **Usage Billing** and pay for the seconds it actually runs, no resource underneath it at all. A workspace can run both at once, and an app on a resource can scale past its plan, with the extra replicas billed by the second.
## Three ways to pay for compute
- **On a resource.** A flat monthly plan. Every app, worker, database and cron job on it draws from the same CPU and RAM, and none of them adds a fee of its own.
- **Usage Billing.** No resource. Each app, service, bucket or stack is billed for what it reserves while it runs, by the second, with no minimum per run.
- **Both.** Keep a resource and put other workloads on Usage Billing in the same workspace, or let an app on a resource scale past its plan - replicas beyond the first are billed by the second instead of needing a bigger plan.
The choice is made once, when a workload is created, and does not change afterward - an app stays on its resource or on Usage Billing for its life.
## What it costs
Usage Billing rates, for a full month of running:
| Resource | Rate |
|---|---|
| RAM | $5.00 / GiB |
| CPU, shared (Hobby) | $8.00 / vCPU |
| CPU, dedicated (Pro) | $24.00 / vCPU |
| Storage | $0.15 / GiB |
| Object storage (buckets) | $0.02 / GiB, for what it holds each hour |
There's a $5/month minimum, and only in a cycle where nothing else on the subscription - no resource, no seat, no add-on - costs more than a cent. Past that, Usage Billing charges automatically once a cycle's usage crosses a threshold, rather than waiting for the renewal: $25 the first cycle, or $5 for the first charge during the free trial, rising with each paid renewal.
One app or PostgreSQL database per account runs free on Usage Billing, at 0.1 vCPU / 256 MiB.
Builds are free either way. They run on Miget's own build machines, never on the resource or the Usage Billing size they're building for, so they're never billed.
## Worker processes, sized and billed on their own
A Procfile's other processes - `sidekiq`, `clock`, a queue worker - are no longer invisible to the dashboard. Each one is recorded, sized from app.json, and shown on the app page with its own pods, logs and (for a Usage Billing app) its cost this cycle.
- Scale a worker on its own, from the dashboard or the API, independently of the web.
- On a resource, a worker takes RAM the way the web does. On Usage Billing, it's billed the way the web is, at its own size.
- A free-tier app's workers wait for Usage Billing to start before running - held with an issue of their own, and started at one replica the moment it does.
```bash
# Scale the "worker" process on its own
curl -X PUT https://app.miget.com/api/v1/apps/$APP_UUID/workers/worker \
-H "Authorization: Bearer $MIGET_API_TOKEN" \
-d '{"replicas": 3}'
```
## An Issues history
Why something stopped - out of room on its resource, a crash loop, killed for memory, waiting on Usage Billing to start, or a cron job's last run failing - is now a record of its own instead of a line buried in a mail. It covers the web, workers, add-ons and services, kept as a history you can scope to one app, one service or one resource, in the dashboard and at `GET /api/v1/issues`.
## Workspace limits, visible before they refuse
The handful of limits that used to surface only as a 422 - replicas on one process, mounts on one shared volume, databases and buckets per workspace - now live in one place, with what you're using against each:
- 20 replicas per process
- 10 apps mounting one shared storage volume
- 40 databases and 100 buckets per workspace
Every one of them can be raised on request. Ask, and an admin approves at a value of their own choosing.
## Cron jobs: sized, with minutes included
Every paid resource plan now includes 1,000 cron minutes a cycle, at the plan's own size, shared across every cron job running on it. Past the pool, per cron job:
- **Pause** until the renewal - the default - or
- **Bill** the overage at the job's own size.
You're mailed at 75% and 100% before anything pauses, and a renewal resumes exactly what the pool paused. Every run is kept - the latest 100 per cron job - with a run history in the dashboard and at `GET /api/v1/apps/{uuid}/cronjobs/{id}/runs`, and a maximum run time from one second up to 24 hours stops a run that's gone too long.
## The enterprise workspace pool
An enterprise contract gets an agreed CPU, RAM and storage capacity instead of a bill that grows with use. Workloads placed in that pool aren't billed by the hour at all - growing past what's left in the pool is refused, and shrinking never is. A contract workspace doesn't run Usage Billing: it has the pool instead.
## The October 2026 price list
Resource, add-on and cron prices moved for new purchases, and nothing an existing resource already pays moves with them. A plan or add-on whose price changes is archived under its own code and replaced by a copy at the new price under the old one - the resources already on it keep running at what they already pay, and you move only by choosing a plan in your resource's settings. The smallest Hobby tier grew from 512 MiB to 1 GiB at the same $5 for everyone; the tier it now matches was retired, with the resources on it kept at their price. The full catalogue, at today's prices, is on [the plans page](/plans).
## Referral credits and spend limits
Credits on a workspace now pay for its Usage Billing beyond the $5 minimum before your card does, whatever other discount your subscription carries, and what's left still comes off the rest of the bill at renewal. Referral credits - 30% of what the people you refer spend - collect on your own account until you transfer them to a workspace where you manage billing; a transfer cannot be undone, and the credits then belong to that workspace.
Two limits keep a Usage Billing cycle from running away on their own: a workspace spend limit caps the whole cycle's bill, and a per-app monthly budget caps what one app can spend by itself. You set both.
## How to use it
Every app, service, bucket and stack form offers Usage Billing next to a resource, with a region and a size to pick from instead of a slider. The API takes the same choice on create:
```bash
# Create an app on Usage Billing instead of a resource
curl -X POST https://app.miget.com/api/v1/apps \
-H "Authorization: Bearer $MIGET_API_TOKEN" \
-d '{"name": "api", "billing": "pay_per_use", "size": "hobby-1c-1g"}'
```
[Compare plans](/plans) · [See use cases priced out](/use-cases) · [Open the dashboard](https://app.miget.com) · [Read the changelog](https://docs.miget.com/changelogs)
---
# Private Networks and VPN Are Live
> Give your apps, databases and services a private network of their own, with internal DNS and no route in from the outside - then reach it over WireGuard, Tailscale, Cloudflare WARP, or an IPsec tunnel to a network you already run.
URL: https://miget.com/blog/private-networking-and-vpn
Date: 2026-08-25
Author: Miget Team
Private networking is live on Miget. Your applications, databases and services can now join a private network of their own, resolve each other by name, and stay unreachable from the public internet. A VPN section sits on top of it, so the same network can be reached from your laptop, your office, or a cloud account you already run.
## What shipped
A new **Networking** section in the dashboard, and a matching set of API endpoints.
- **A network per region.** Every workload in a region can share one private network. Until now, an application on one resource had no private path to a database on another. It does now.
- **A subnet and a resolver, ready on creation.** A new network comes up with a `/24` already carved out and a DNS resolver of its own. The usual path is: create it, attach the database, attach the application, done.
- **A workload answers to a name, not to an address.** The name is what belongs in a connection string. The address behind it moves whenever the workload rolls, and the name does not.
- **An address range you control.** The default is `10.224.0.0/16`. Anything RFC1918 and `/22` or larger works, and a range that would clash with the platform is refused as you type it rather than failing later.
## Reaching it from outside
Four terminators, and you can run more than one on the same network.
- **WireGuard**, per person or per machine. Add a device, download its configuration, import it. The private key is generated for the device and never stored, so the file downloads exactly once - if it is lost, delete the device and add another.
- **Tailscale**, joining a tailnet you already run with an auth key.
- **Cloudflare WARP**, joining a Cloudflare organization with a service token.
- **IPsec site-to-site**, joining a whole remote network: an AWS VPC, a data centre, an office.
Tailscale and Cloudflare WARP need routes telling the network which ranges live behind them, because those ranges live in your configuration rather than ours. Routes are staged and applied together, because applying restarts every attached workload - so you add every range you need and pay that cost once.
## What it costs
The private network itself is on every plan. The terminators are priced per option:
- **$29/mo per gateway you enable.** Per gateway, not per network, so a network running both WireGuard and Tailscale is charged twice.
- **$199/mo per site-to-site tunnel**, because each tunnel permanently holds one of the region's public addresses.
Both are included on Enterprise plans.
## How to use it
### From the dashboard
Open **Networking**, create a network, and attach the workloads you want on it. Attaching restarts the workload - an interface cannot be added to a running container - so for a database that means a database restart, and the confirmation dialog says so before you commit. An application created with a network chosen up front skips the restart entirely.
Add a VPN from the **Add VPN** menu on the network, and for Tailscale or Cloudflare WARP stage the peer ranges and apply them together.
### From the API
```bash
# Create a network in a region
curl -X POST https://app.miget.com/api/v1/vpcs \
-H "Authorization: Bearer $MIGET_API_TOKEN" \
-d '{"region_id": "...", "cidr_v4": "10.224.0.0/16"}'
# It answers pending. Poll until status is active, then read the
# derived resolver, the v6 range and the VPN pool.
curl https://app.miget.com/api/v1/vpcs/$VPC_UUID \
-H "Authorization: Bearer $MIGET_API_TOKEN"
# A default subnet already exists - list it rather than creating one
curl https://app.miget.com/api/v1/vpcs/$VPC_UUID/subnets \
-H "Authorization: Bearer $MIGET_API_TOKEN"
# Attach a workload
curl -X POST https://app.miget.com/api/v1/vpcs/$VPC_UUID/attachments \
-H "Authorization: Bearer $MIGET_API_TOKEN" \
-d '{"subnet_uuid": "...", "attachable_type": "Addon", "attachable_uuid": "..."}'
```
An application can join a network at creation time instead, with `vpc_subnet_uuid` on `POST /api/v1/apps` - which avoids the restart an attach costs.
Access is governed by a new `network:*` permission group: `network:view` to read, `network:operate` to attach and detach, `network:manage` for everything else. Site-to-site connections are limited to the workspace owner, because each one spends a public address and moves the bill.
## Some deliberate limits
- **A network cannot span regions.** A workspace working in two regions gets one network in each.
- **The name and the address range are fixed once created.** The whole address plan is derived from them on every action, so they cannot drift.
- **Storage cannot be attached** - a volume has no pod to address - and neither can an addon that belongs to a managed service.
- **An attachment's name goes stale after a rollout** until the next attach, detach or route change, and a cron job gets no name at all.
## What is next
The dashboard covers all four terminators today. The API covers networks, subnets and attachments, plus gateways, devices, routes and site connections. The full endpoint list, including the `410` you get from reading a WireGuard configuration twice, is in the [API changelog](https://docs.miget.com/changelogs).
[Open the dashboard](https://app.miget.com) · [Read the docs](https://docs.miget.com) · [Compare plans](/plans)
---
# Project Access, Resource Assignment and Workspace API Tokens
> Close a project to the people who need it, dedicate a compute resource to the projects allowed to deploy on it, and issue API tokens that belong to the workspace rather than to a person.
URL: https://miget.com/blog/project-access-and-resource-assignment
Date: 2026-08-24
Author: Miget Team
Three changes shipped together, and they answer the same question: who is allowed to see and use what, inside a workspace that has grown past a handful of people.
## Projects can be closed
On Organization and Enterprise plans, a project can be restricted to a chosen list of members and roles.
A project someone cannot reach is **not shown to them at all** - not its applications, not its services, not its buckets. It is not listed and then refused, which tells people a project exists and that they are not in it. The workspace owner and the built-in Admin role always keep access, so a restriction cannot lock the workspace out of its own project.
This is the piece that makes a shared workspace usable for agency work: one client per project, and the people on that client's work are the only ones who see it.
## Resources can be assigned to projects
A compute resource can now be dedicated to specific projects, under **Project - Settings - Resources**. Only the projects it is assigned to may deploy on it.
Two things are worth being precise about, because the direction is easy to get backwards:
- **Assigning restricts the resource, never the project.** A project with assigned resources can still deploy to the shared pool. The assignment says who may use the box, not where the project must run.
- **If the resource still runs workloads from another project, the refusal names them** and offers to assign the resource to those projects too, instead of failing with nothing to act on.
Removing an assignment returns the resource to the shared pool and moves nothing that is already running.
## Everything can change project
Applications, static sites, services, stacks and buckets can all move between projects from their own settings. A stack takes every application and service it runs with it. The workload keeps running on the same resource throughout - a project is an organisational boundary, not a placement.
Buckets became project-owned in the same release: a bucket can sit in a project like everything else, or stay at workspace level.
## API tokens that belong to the workspace
Workspace API tokens are separate from personal ones. A workspace token has its own permission list and its own project scope, and:
- It keeps working when the person who created it changes role.
- It stops working when that person loses access to the workspace.
- Editing one takes effect immediately, and lands on the activity feed with an author.
The practical difference is CI. A pipeline authenticated with somebody's personal token breaks the day that person's role changes, and quietly keeps working the day they leave. A workspace token does neither.
API tokens and webhooks now live in their own **Developers** tab in workspace settings, leaving Integrations for connections to other products.
## How to use it
Restrictions and assignments are dashboard features today, under the project's own settings. Workspace tokens are created in **Settings - Developers**, and behave like any other bearer token against the API:
```bash
curl https://app.miget.com/api/v1/apps \
-H "Authorization: Bearer $MIGET_WORKSPACE_TOKEN"
```
A token's permissions are the intersection of what you granted it and what its owner may do, so a token can never be used to exceed the access of the person it belongs to.
[Open the dashboard](https://app.miget.com) · [Read the docs](https://docs.miget.com) · [Compare plans](/plans)
---
# Static Sites: Free Hosting for a Built Site
> Deploy prebuilt HTML, CSS and JavaScript from GitHub, a git push, an SFTP upload or a zip file, with framework detection across 33 generators. No compute resource behind it, and no charge for it.
URL: https://miget.com/blog/static-sites-on-miget
Date: 2026-08-22
Author: Miget Team
Static sites are now a first-class resource on Miget, and they are **free**. Not free-tier free, not free-until-you-grow free: a static site costs nothing, on any plan, with no cap on how many you run.
A built site does not need a container, a replica or a port. It is served straight from object storage, so it does not need a compute resource - and it does not consume the one you are already paying for. Your applications keep the whole plan to themselves.
## Four ways in
- **GitHub.** Connect a repository, pick a branch, and every push builds and publishes.
- **Git Push.** Push to a Miget remote, same as an application.
- **Zip upload.** Drag a built bundle onto the page.
- **SFTP.** Upload a directory with the tooling you already use.
## Builds with nothing to configure
For the git-based sources, Miget detects the framework across 33 generators and builds with that generator's defaults. When detection gets it wrong, override the generator, the build command, the output directory, or the path to a site inside a monorepo.
**SPA mode** serves `/index.html` for unknown paths, so client-side routes survive a refresh instead of returning a 404.
## Deployment history you can act on
- **Cancel a running build** without waiting for it to fail.
- **Roll back a GitHub site** to the commit a previous deployment shipped.
- **Browse the files currently deployed**, to confirm what actually landed rather than what you think you pushed.
Custom domains work exactly as they do for applications, with the same automatic TLS.
## What it costs
Nothing. There is no per-site charge, no build-minute charge, and no bandwidth charge - Miget does not meter bandwidth on any plan. A static site is not a component on your subscription, so adding one does not change your bill and deleting one does not reduce it.
That also means a static site does not need a paid plan behind it. An account on the free tier can run them.
## When to use one
A static site is the right resource for documentation, a marketing site, a landing page, a client's brochure site, or the built output of any front-end framework that produces files rather than a server. Anything that has to run code on request - server-side rendering, an API, a form handler - is still an application.
The practical effect is that the small sites that used to sit awkwardly on a compute plan stop competing with your applications for it.
[Open the dashboard](https://app.miget.com) · [Read the docs](https://docs.miget.com) · [Compare plans](/plans)
---
# Self-Hosted Slack Alternatives, and the One Part You Cannot Self-Host
> Mattermost, Rocket.Chat and Zulip compared on the two things that decide a migration: which one is actually open source across the whole repository, and why mobile push notifications still route through the vendor.
URL: https://miget.com/blog/self-hosted-slack-alternatives
Date: 2026-08-21
Author: Miget Team
Slack's per-seat pricing has the same shape as every other per-seat product: the number of people who need to read messages grows faster than the number of people producing anything, and each of them is a full seat. Add contractors and the bill stops tracking the value.
So teams go looking for something they can run themselves. The candidates are well known. What is less well known is the pair of details that actually decide how the migration goes, and neither of them appears on a feature comparison table.
## Which of these is actually open source
Read from the repositories themselves, on 17 August 2026:
| Project | Stars | Licence as GitHub reports it | What the repository shows |
| --- | --- | --- | --- |
| Rocket.Chat | 46.0k | **NOASSERTION** | One `LICENSE`, plus a separate `ee/` directory |
| Mattermost | 38.8k | **NOASSERTION** | Ships `LICENSE.txt` **and** `LICENSE.enterprise` |
| Zulip | 25.7k | **Apache-2.0** | A single licence across the repository |
| Synapse (Matrix) | 4.5k | AGPL-3.0 | Reference server for the Matrix protocol |
"NOASSERTION" is GitHub's way of saying it could not resolve the repository to one standard licence. In both cases the reason is the same open-core arrangement: a freely licensed core, plus a directory of enterprise features under separate commercial terms. Mattermost makes it explicit with a second licence file; Rocket.Chat keeps the enterprise edition in `ee/`.
None of this is hidden and none of it is wrong. It matters for one specific reason: if your motivation for leaving Slack includes a policy requirement that the software be OSI-licensed, **Zulip is the only one of the three that satisfies it across the whole codebase**.
We should be straight about the consequence for us. Our catalogue ships Mattermost and Rocket.Chat, each with a tuned compose file. It does not ship Zulip. If the licence is your deciding factor, the honest answer is that the one you want is not one we have packaged, and you would be deploying it yourself.
## The part you cannot self-host
Here is the detail that surprises people after the migration rather than before it.
You can run the server. You cannot run the mobile push notifications, at least not without more work than anyone expects.
Push delivery to an iOS or Android app goes through Apple's and Google's push services, and both tie delivery to the credentials of the app as published in the store. The official Mattermost and Rocket.Chat mobile apps were published by Mattermost and Rocket.Chat. So when your self-hosted server needs to wake a phone, the notification is relayed through the vendor's push service, because only the vendor holds the keys that Apple and Google will accept for that app.
This is not a secret. Mattermost publishes its push proxy as a separate Apache-2.0 project, [mattermost-push-proxy](https://github.com/mattermost/mattermost-push-proxy), precisely so you can run that hop yourself. But running it only helps if you also build, sign and distribute **your own** mobile app, because the proxy needs certificates for an app you control. For most teams that is a bigger project than the migration was.
The practical read:
- If your requirement is **cost or control of your data at rest**, this changes nothing. Configure the notification content to carry no message body and the relay carries only a wake-up.
- If your requirement is **that no third party sees any metadata about your communications**, then plan for either a custom mobile app or desktop and web clients only. Decide this before you migrate, not after someone asks.
## Mattermost or Rocket.Chat
For teams that are not licence-constrained, this is the real choice, and the two differ most in the shape of what you end up operating. Read from the compose files we ship:
**Mattermost** runs `mattermost-team-edition` against **PostgreSQL**, and keeps state across several volumes: configuration, data, logs, plugins, client plugins, and a Bleve search index. Only configuration, data and the database really need backing up; the logs, plugins and search index rebuild. But you have to know that, because a naive "back up every volume" is heavier than it needs to be, and a naive "back up one volume" loses your configuration.
**Rocket.Chat** runs against **MongoDB** with a single data volume. Simpler to back up, and a different database to operate. If your team already runs Postgres and has never run Mongo, that is a real consideration and it points at Mattermost.
Beyond operations: Mattermost is the more conservative, more Slack-shaped product, and the one to pick if the goal is for nobody to notice the change. Rocket.Chat casts wider, with omnichannel and customer-facing chat features, which is an advantage if you want them and surface area you do not need if you do not.
**Zulip** deserves a mention on its own merits rather than just its licence. Its threading model is genuinely different - conversations are organised by topic within a channel rather than as a flat stream - and teams that adopt it tend to be emphatic about it. It is the one option here that is not trying to be Slack.
## What it costs to run
Each of these is one application container plus one database. The bill becomes the machine rather than the headcount, which was the entire point of leaving.
On a flat plan starting at $5 a month they run beside whatever else you already host. The saving is real, but be honest about what replaces the cost: someone now owns upgrades, backups and the restore test.
## When to stay on Slack
Stay if the integrations are load-bearing. Slack's app directory is the product for a lot of teams, and the equivalents are thinner.
Stay if the people using it are non-technical and the polish is why it works. This is the same conversation as every self-hosting migration, and the people who feel the difference are the ones who never asked what the software was called.
Stay if nobody will own the upgrades. An abandoned self-hosted chat server is worse than a bill.
Move if the seat count is what is growing, if the messages have to sit on infrastructure you control, or if you want a chat system that outlives a pricing change.
## Frequently asked questions
**What is the best self-hosted Slack alternative?**
Mattermost if you want the least disruption and already run Postgres. Rocket.Chat if you want a broader product and are comfortable with MongoDB. Zulip if you want a single OSI licence across the codebase, or if its topic-based threading appeals.
**Is Mattermost open source?**
The core is, but the repository also ships `LICENSE.enterprise` covering enterprise features. GitHub reports the repository as NOASSERTION for that reason. The same is true of Rocket.Chat, which keeps its enterprise edition in an `ee/` directory.
**Do mobile push notifications work on a self-hosted server?**
Yes, but they are relayed through the vendor's push service, because push delivery is tied to the credentials of the app published in the app stores. You can run the relay yourself only if you also publish your own mobile app.
**Can I import my Slack history?**
Mattermost and Rocket.Chat both provide Slack import tooling that reads Slack's export. Expect channels and messages to travel well, and integrations, workflows and some formatting not to. Run the import into a scratch instance first.
**What do I need to run one?**
The application container, its database, and a volume. Any small instance handles a team-sized deployment; the ongoing work is upgrades and backups, not capacity.
## What to read next
- [Notion alternatives you can host yourself](/blog/notion-alternatives-self-hosted)
- [Self-hosting a password manager](/blog/self-host-password-manager)
- [Airtable alternatives you can host yourself](/blog/airtable-alternatives-self-hosted)
---
# Self-Hosting a Password Manager: What You Are Actually Taking On
> Self-hosting a password manager changes less about security than people assume, and more about backups than they expect. The options, the licence detail nobody mentions, and the failure mode that should decide it for you.
URL: https://miget.com/blog/self-host-password-manager
Date: 2026-08-20
Author: Miget Team
The usual objection to self-hosting a password manager is that it sounds reckless. Putting every credential your company owns on a box you administer yourself feels like the last thing a sensible person would do.
That instinct is aimed at the wrong risk. It is worth understanding why before you decide either way, because the real trade-off is not the one most articles argue about.
## The part that changes, and the part that does not
In a Bitwarden-compatible password manager, your vault is encrypted on your device. The key is derived from your master password, which never leaves the client. What the server stores and syncs is ciphertext, and the server operator cannot read it.
That is true whether the operator is Bitwarden or you. So moving the server to your own infrastructure does not hand you the burden of keeping the contents secret - the contents were already opaque to the server. Someone who steals your database gets an encrypted blob and your master password's key derivation to fight.
What you do take on is **availability**. If your instance is down, nobody can sync. If your volume is gone and your backup was never tested, the vault is gone with it, and there is no support line that can restore it, because nobody else ever had the plaintext.
Self-hosting a password manager is therefore a backup problem wearing a security costume. Decide it on whether you will genuinely run backups, not on whether you trust yourself with secrets.
## The licence detail nobody mentions
Here is something that does not appear in any of the comparison lists we read while writing this.
Bitwarden's server repository is not under a single open-source licence. It ships `LICENSE_AGPL.txt` **and** `LICENSE_BITWARDEN.txt`, alongside a `bitwarden_license/` directory covered by the second one. Read from the repository on 17 August 2026, that directory contains these modules:
`Commercial.Core` · `Commercial.Infrastructure.EntityFramework` · `Scim` · `Services` · `Sso`
**SSO and SCIM are in there.** Which is to say: the two features an organisation is most likely to want when it self-hosts a password manager - single sign-on and automated user provisioning - are the ones outside the AGPL portion of the codebase.
This is not a scandal. It is a normal open-core arrangement and Bitwarden documents it. It is just worth knowing before you plan an architecture around self-hosting, because "Bitwarden is open source" is true of most of it and not of the parts an IT department reaches for first.
It also explains something that looks odd at first glance: Vaultwarden, an unofficial reimplementation of the Bitwarden server API, has **65.5k GitHub stars against the official server's 19.9k**.
## The options
Read from the projects themselves:
| Project | Stars | Licence | Notes |
| --- | --- | --- | --- |
| Vaultwarden | 65.5k | AGPL-3.0 | Rust reimplementation of the Bitwarden API; works with the official clients |
| KeePassXC | 28.4k | GPL family, no single SPDX identifier | A local database file, not a server |
| Bitwarden server | 19.9k | **AGPL + Bitwarden Licence** | Official; SSO and SCIM under the proprietary portion |
| Passbolt | 6.1k | AGPL-3.0 | Built for teams from the start, PHP |
| Psono | small on GitHub | source-available | Primary development is on GitLab, not GitHub |
**Vaultwarden** is the pragmatic answer for most people, and the one in our catalogue. It speaks the Bitwarden API, so the official desktop, mobile and browser clients work against it unmodified, and it runs as one small Rust binary instead of a multi-container deployment. If you want Bitwarden's clients without Bitwarden's server footprint, this is why it exists.
**Passbolt** is the better fit if sharing credentials across a team is the actual requirement rather than an afterthought. Its permission model was designed for that rather than grown into it.
**KeePassXC** deserves a mention because it solves the problem differently and often better for individuals: there is no server at all, just an encrypted file you sync however you already sync files. No server means no server to run, patch, or lose.
**Bitwarden's own server** is the right choice when you need SSO or SCIM and are prepared to license them, or when your organisation requires a vendor relationship.
## What it actually costs to run
Our Vaultwarden stack is one container, `vaultwarden/server` pinned to 1.36.0, with a single data volume. That is the entire deployment.
The practical consequence is that a password manager is one of the cheapest things you can self-host. It sits beside everything else you already run rather than justifying its own machine, and on a flat plan starting at $5 a month it is not the line item that moves the bill.
Which brings the decision back to the thing that actually matters.
## Get the backups right or do not do this
Everything above is easy. This is the part that is not, and it is the only part that can lose you the vault.
- **Back up the data volume, not just the container.** The container is disposable and rebuildable. The volume is the vault.
- **Test a restore before you migrate anyone onto it.** An untested backup is a belief, not a backup. Restore into a scratch instance and log in.
- **Keep an offline export.** Every Bitwarden-compatible client can export the vault. An encrypted export stored somewhere unrelated to your infrastructure is what saves you when the infrastructure is the thing that failed.
- **Write down the recovery path for the person who is not you.** If the only human who knows how to restore it is also the only human with the master password, you have built a single point of failure with a pulse.
None of this is exotic. It is the same discipline any stateful service needs. The difference is that with a password manager there is no vendor-side copy to fall back on, which is precisely the property you were looking for.
## When not to self-host
Do not self-host if the honest answer to "who tests the restores?" is nobody. A hosted password manager with someone else's operational discipline beats a self-hosted one with none, and this is not a close call.
Do not self-host if you need SSO and SCIM and were counting on getting them for free - see the licence section.
Do not self-host if the motivation is cost alone. A password manager is rarely the largest line on anyone's bill, and it is a poor place to look for savings relative to what you take on.
Do self-host if the credentials must sit on infrastructure you control for compliance reasons, if you are already running and backing up other stateful services and this is one more, or if you want the reassurance of knowing exactly where the vault lives.
## Frequently asked questions
**Is it safe to self-host a password manager?**
The vault is encrypted client-side, so the server never holds plaintext and self-hosting does not expose the contents. The risk you take on is availability and backup discipline, not confidentiality.
**Is Vaultwarden safe to use instead of official Bitwarden?**
It is an independent AGPL-3.0 reimplementation of the server API, not an official product, and it is widely used - 65.5k stars against the official server's 19.9k. The clients are unchanged, so the encryption model is the same. Evaluate it as you would any third-party server implementation, which means reading its release notes and keeping it updated.
**Is Bitwarden fully open source?**
Most of the server is AGPL, but the repository also carries a separate Bitwarden Licence covering the `bitwarden_license/` directory, which includes the SSO and SCIM modules.
**What do I need to run one?**
For Vaultwarden: one container and one persistent volume. The ongoing work is backups, not capacity.
**Can I move my existing vault in?**
Yes. Every Bitwarden-compatible client exports and imports the vault, and Vaultwarden accepts the same format. Export from the old instance, import into the new one, verify a few entries by hand, and only then remove the old one.
## What to read next
- [Notion alternatives you can host yourself](/blog/notion-alternatives-self-hosted)
- [Airtable alternatives you can host yourself](/blog/airtable-alternatives-self-hosted)
- [DocuSign alternatives you can host yourself](/blog/docusign-alternatives-open-source)
---
# Mintlify Alternatives: What You Are Actually Choosing Between
> Every Mintlify alternatives list is written by someone selling a docs product. We pay for Mintlify and wrote the exporter, so here is the comparison without a horse in the race - including the one dimension nobody checks.
URL: https://miget.com/blog/mintlify-alternatives
Date: 2026-08-19
Author: Miget Team
Search for Mintlify alternatives and you will find lists written by GitBook, by Ferndesk, by Featurebase, by Documentation.AI. Every one of them concludes that the best alternative to Mintlify is the product that published the list.
We have no docs product to sell. We pay for Mintlify, [docs.miget.com](https://docs.miget.com) runs on it, and last week we published [the tool that exports it to static files](/blog/self-host-mintlify-docs-static). That gives us an unusual position: we like Mintlify, we have read its output closely enough to rebuild it, and we have no reason to talk you out of it.
So this is the comparison we wish we had found.
## First, the honest question
Most people arriving at this search are not unhappy with Mintlify's writing experience. They are hitting one of three walls: the docs need to live on their own infrastructure and self-hosting is Enterprise-only, the per-seat bill stopped matching the value, or they want to know how bad the exit would be before committing further.
Those are three different problems, and only one of them is solved by switching tools. If the wall is hosting, [an export](/blog/self-host-mintlify-docs-static) keeps the writing experience and moves the serving. If the wall is price or exit risk, keep reading.
## The dimension nobody checks
Comparison lists rank docs tools on themes, MDX support, API playgrounds and AI features. They almost never mention search, which is strange, because search is the piece most likely to turn into someone else's invoice.
We only noticed because of the export. Mintlify's search box posts to `/api/search`, which means it is a service, not a file. Pull the site down to static and the search box stops working until you stand up a backend. That sent us checking what everyone else does, and the answer does not split the way you would expect.
Read from the projects themselves:
| Tool | Stars | Licence | How search works |
| --- | --- | --- | --- |
| Docusaurus | 65.9k | MIT | Official package is `docusaurus-theme-search-algolia` - **a hosted service** |
| MkDocs Material | 27.3k | MIT | Ships `lunr` plus `search` and `offline` plugins - **fully in the bundle** |
| VitePress | 18.2k | MIT | Ships `minisearch` for local search, Algolia optional - **your choice** |
| Fumadocs | 12.9k | MIT | Built-in, swappable engine |
| Starlight | 9.1k | MIT | Ships `pagefind` as a direct dependency - **fully in the bundle** |
| Mintlify | closed | proprietary | Hosted `/api/search` endpoint |
The surprise is Docusaurus. It is the biggest open-source option by a wide margin, it is Meta-backed and MIT licensed, and its official search route is Algolia DocSearch - a hosted service, free for qualifying open-source projects and a paid plan otherwise. Community plugins add local search, but the supported path points off your infrastructure, exactly like the tool you are trying to leave.
The two that genuinely put a search index inside the build output are **Starlight** and **MkDocs Material**. If "our docs must work with no third party involved" is on your list, that list is shorter than it looks.
## The realistic options
**Starlight** is the closest thing to a drop-in for someone who liked Mintlify. Astro-based, MIT, Pagefind search in the bundle, and it looks finished out of the box rather than looking like a default theme. If we were starting over today, this is what we would evaluate first.
**MkDocs Material** is the most complete self-contained option, and the one to pick when the docs must survive with no external calls at all - it ships an `offline` plugin for exactly that. One caveat worth knowing before you commit: the project runs a sponsorware model, where a set of features live in a private "Insiders" fork available to sponsors and graduate to the public MIT release over time. The public version is genuinely MIT and genuinely good. You just want to know which features you are looking at in the documentation before you plan around them.
**Docusaurus** is the safe institutional choice. Enormous ecosystem, versioned docs and i18n that actually work, and it will still exist in five years. Budget for the search decision rather than accepting the default.
**VitePress** is the fastest to stand up if your team already writes Vue, and its local search is one config line.
**Fumadocs** is the closest in spirit to Mintlify among the Next.js options and moves quickly. Newer and smaller, which cuts both ways.
For **API reference specifically**, the comparison is different: Redoc (25.9k, MIT) and Scalar (15.9k, MIT) both render an OpenAPI spec into a browsable reference, and either can sit next to any of the tools above. Slate (36k stars) still turns up on these lists, but its last push was February and it carries no SPDX licence identifier in its repository metadata - check that before adopting it.
## What you give up
Every option above is a static site generator. Mintlify is a product. Moving means you stop paying for, and stop receiving:
- The web editor, so non-technical contributors go back to pull requests
- Preview deployments per branch, unless you build them
- The assistant and the analytics
- Someone else's problem becoming your problem when the build breaks
That last one is the real cost and it does not appear on any pricing page. A docs site you generate yourself is a small piece of infrastructure you now own.
## When to stay
Stay on Mintlify if the writing experience is why your team actually writes documentation. That is not a small thing - most documentation problems are "nobody writes it" problems, and a tool people enjoy solves more than a tool that is cheaper.
Stay if you need the hosted extras. And if self-hosting is a hard organisational requirement with a budget attached, talk to Mintlify about Enterprise rather than rebuilding.
Move if the seat count is what is growing, if the content has to sit on infrastructure you control, or if you want the rendered site to be files you own outright.
There is also a third path people miss: keep writing in Mintlify and [export the rendered site to static files](/blog/self-host-mintlify-docs-static). You keep the editor and move the hosting. It is not a permanent answer to a pricing problem, but it is a very good answer to a hosting one, and it buys you time to make the bigger decision calmly.
## What it costs to run any of these
All of them build to static files, so hosting is whatever serves a directory. Ours run beside everything else we operate on a flat plan starting at $5 a month, and the docs site is not the reason that number moves.
That is worth stating plainly because it inverts the usual comparison. Once you leave a per-seat docs product, the hosting cost stops scaling with how many people read or write the documentation, and starts being a rounding error on infrastructure you already pay for.
## Frequently asked questions
**What is the closest alternative to Mintlify?**
Starlight, for the combination of a finished-looking theme, MDX authoring and search that ships inside the build. Fumadocs is closest if you need to stay on Next.js.
**Can I self-host Mintlify?**
On the Enterprise tier, quoted per organisation. On Starter and Pro the published docs live on Mintlify's infrastructure, though you can [export the rendered site](/blog/self-host-mintlify-docs-static) and serve it yourself.
**Which docs tools have search that works without a third-party service?**
Verified from the projects: Starlight bundles Pagefind, MkDocs Material bundles lunr and ships an offline plugin, and VitePress bundles MiniSearch. Docusaurus's official search package is Algolia DocSearch, a hosted service.
**Is Docusaurus better than Mintlify?**
Different products. Docusaurus is a generator you run and own; Mintlify is a service you rent. Docusaurus wins on control, cost at scale and longevity. Mintlify wins on the day-to-day experience of writing and shipping docs.
**Do I have to rewrite my content to switch?**
Usually not the prose - all of these read Markdown or MDX. The work is in frontmatter, navigation configuration, and any Mintlify-specific components you used. Audit those before estimating the migration.
## What to read next
- [How to self-host Mintlify docs as a static site](/blog/self-host-mintlify-docs-static)
- [Notion alternatives you can host yourself](/blog/notion-alternatives-self-hosted)
- [Airtable alternatives you can host yourself](/blog/airtable-alternatives-self-hosted)
---
# How to Self-Host Mintlify Docs as a Static Site
> Mintlify offers self-hosting on Enterprise. Everyone else can export the rendered docs to a static bundle and host them anywhere - here is the open-source tool we built for it, and the honest list of what it does not cover.
URL: https://miget.com/blog/self-host-mintlify-docs-static
Date: 2026-08-18
Author: Miget Team
Mintlify is a good way to write documentation. The writing experience is genuinely pleasant, the API playground works, and the output looks like the docs of a company much larger than yours.
Then someone asks where the docs are hosted, and whether they can live on your own infrastructure. Mintlify's answer is that self-hosting is available on Enterprise, which is quoted per organisation. On Starter and Pro your published docs live on their infrastructure, and that is the end of the conversation unless you want to have a different one with sales.
This post is about the third option: keep writing in Mintlify, and export the rendered site to static files you host yourself.
## Why anyone wants this
Three reasons come up, in roughly this order.
**The docs have to be on your infrastructure.** Sometimes that is a compliance requirement, sometimes it is a policy about what runs on which domain, and sometimes it is just that everything else you operate is already yours and the docs are the odd one out.
**Nobody wants a second bill for HTML.** Documentation is static content. Paying a per-seat subscription to serve it starts to feel strange the moment you already run a CDN.
**Lock-in, but the boring kind.** The MDX is yours and always was. What is not obviously yours is the rendered site: the theme, the navigation, the client-side routing, the search page, the generated API reference. If the relationship ends, you would like to keep serving the thing you already have while you decide what is next.
## What we built
We hit the first reason. [docs.miget.com](https://docs.miget.com) is written in Mintlify, and we wanted it served from our own infrastructure like everything else we run.
So we wrote [staticmint](https://github.com/migetapp/staticmint), a Go tool that turns a Mintlify docs repo into a directory of static files. It is MIT licensed, contains no Mintlify code, and it is what serves docs.miget.com in production today.
The approach is deliberately unclever. `mint dev` is a real production Next.js server rendering your docs exactly as Mintlify renders them. staticmint starts it, crawls it, and writes the result to disk. Nothing re-implements Mintlify's renderer, so nothing drifts from it.
## What comes out
Running it against a docs repo produces a bundle that is more than a pile of HTML:
- Every route as `route/index.html`, enumerated from the fully resolved navigation, including pages auto-generated from OpenAPI specs and hidden pages that are routable without appearing in the nav
- `route/index.rsc`, the React flight payload the Next router fetches during client-side navigation, so the instant page transitions keep working
- The whole `_next/static` build tree, so lazy-loaded chunks and fonts resolve
- The styled 404 page, `favicon.ico`, `sitemap.xml` and `robots.txt` generated from the real exported route list
- Each page's MDX source as a `.md` companion, plus `llms.txt` and `llms-full.txt`
- `docs.json` redirects materialized as static stubs
Then it verifies that every internal link and asset reference in the bundle actually resolves, and exits non-zero if anything is missing. That last part is what makes it safe to gate a CI job or an image build on.
## Running it
From the directory containing your `docs.json`:
```sh
staticmint -start-server -site-url https://docs.example.com
```
That starts `mint dev`, waits for it, exports into `./out`, stops the server and verifies the result. If you already have a preview running, point it at that instead:
```sh
mint dev --no-open &
staticmint -site-url https://docs.example.com -out dist
```
You need the `mint` CLI available; logged-out local usage is fine. Prebuilt binaries exist for Linux, macOS and Windows on both architectures, or `go install github.com/migetapp/staticmint@latest`.
The bundle uses clean URLs, so any host that serves `index.html` for directory paths will work. Two things are worth configuring: serve `404.html` as the custom 404, and serve `route/index.rsc` as `text/x-component` when a request carries the `RSC: 1` header. Without the second one, client-side navigation degrades gracefully to full page loads. There is an nginx config in the repo that does both.
## What it does not do
This is an export, not a replacement, and the honest list matters more than the feature list.
**Search needs a backend.** The search box posts to `/api/search`, and a directory of files cannot answer a POST. This is the one gap that stops the export being a drop-in, so the next section covers exactly how we closed it.
**OpenAPI-generated pages have no `.md` companion.** Those pages have no MDX source, so their `.md` links return 404.
**It depends on Mintlify internals.** The `~/.mintlify` layout, `generatedDocsNav.json`, the flight payload behaviour. It was built against `mint` 4.2.800 with client 0.0.3447. Pin your `mint` version if you want reproducible builds. When upstream changes something, the export fails loudly rather than quietly producing a broken site, which is the behaviour you want.
**The bundle is a snapshot.** Re-run the export on every content change. In practice that is one CI step.
**You keep none of the hosted product.** The web editor, the assistant, preview deployments, insights - those are the service you were paying for, and they stay with the service.
## Making search work
staticmint deliberately does not ship a search backend, because which one you want is your decision. Here is what runs behind docs.miget.com, which is about a hundred lines of glue in total.
**A search engine next to the bundle.** We run [Meilisearch](https://www.meilisearch.com) as a second process on the same host, listening on localhost only, with its database on a persistent volume. It is small, it needs no tuning for a documentation-sized corpus, and it answers in single-digit milliseconds.
**One nginx location.** The endpoint the docs already call gets pointed at Meilisearch's search route:
```nginx
location /api/search {
proxy_pass http://127.0.0.1:7700/indexes/docs/search;
proxy_http_version 1.1;
proxy_set_header Content-Type application/json;
proxy_cache off;
}
```
**An indexer that reads your MDX.** A short Node script walks the docs repo, pulls `title` and `description` out of each file's frontmatter, strips the frontmatter, keeps the text, and pushes one document per page into a `docs` index:
```js
{
id: slug.replace(/\//g, '-'),
slug: '/' + slug,
title,
description,
content: textContent.substring(0, 10000)
}
```
Capping the body keeps documents small enough that the whole index stays comfortably in memory. Run it once at startup, after the engine reports healthy, and again whenever content changes.
**And the part worth stealing: replace the search UI rather than emulate it.** Mintlify's own search component expects its hosted API's response shape, and chasing that shape across upstream releases is a losing game. It is far less work to inject a small script that renders your own search modal and queries the endpoint directly. Ours is one injected `