Host a FastMCP server and keep it online
Your MCP server works locally. Now give Claude, Cursor, ChatGPT, or your own agent an HTTPS endpoint it can actually reach.
Deploy your FastMCP project to Dockhold from GitHub, or straight from the folder on your computer. Dockhold builds it, keeps it running, and gives you a live HTTPS URL. No VPS to set up, no servers to manage, and no leaving your laptop awake so a client can call your tools.
From local MCP server to live endpoint
If your FastMCP server already runs on your machine, you are most of the way there. Dockhold takes care of everything around it:
- an always-on runtime, so the server is up when a client calls it
- a public HTTPS URL, with certificates issued and renewed for you
- automatic deploys on every push to your GitHub repository
- direct deploys from your project folder with
npx dockhold deploy - environment variables and encrypted secrets for your API keys
- a managed Postgres database when your server needs to remember things
- hosting in the EU
Your MCP implementation stays your implementation. Dockhold just gives it somewhere permanent to run.
The one change most FastMCP servers need
Locally, MCP servers usually talk over stdio. To be reachable over the web yours needs to serve the Streamable HTTP transport, listening on the port Dockhold hands it:
import os
from fastmcp import FastMCP
mcp = FastMCP("my-server")
@mcp.tool
def add(a: int, b: int) -> int:
"""Add two numbers."""
return a + b
if __name__ == "__main__":
mcp.run(
transport="http",
host="0.0.0.0",
port=int(os.environ.get("PORT", 8000)),
)
Your app must listen on 0.0.0.0 and read its port from the
PORT environment variable, never localhost and never a
hardcoded port. Dockhold assigns PORT at runtime; an app that
ignores it can't receive traffic.
That is the whole change. Your tools, resources, and prompts stay exactly as you wrote them. On older FastMCP releases the transport is called streamable-http instead of http. Either way, clients connect at https://<your-app>.dockhold.app/mcp.
Built for servers that need to stay reachable
MCP clients call your server when they need it, not on a schedule you get to pick. Dockhold apps don’t sleep when traffic stops, so your endpoint answers the first call of the day as quickly as the hundredth. There is no cold start to wait through and no request timeout to design around.
That matters most for agents, automations, webhooks, and any tool that gets called at irregular intervals.
Deploy it
From a GitHub repository:
- Connect GitHub Authorize Dockhold once, from the dashboard.
- Pick the repository Choose the repo your server lives in.
- Deploy Dockhold detects the project and builds it.
- Copy your URL Point your MCP client at it.
Or, from your project folder:
npx dockhold deployThat’s it. A GitHub-connected app redeploys itself every time you push. For a folder you deployed from your computer, run the same command again to ship a new version.
Your MCP server doesn’t have to be public
Building something internal? On a paid plan you can lock an app behind an access token that is checked at the edge, before the request ever reaches your code. Anything without a valid token is turned away.
That’s useful for internal tools, staging environments, admin APIs, and any MCP server you would rather not leave open to whoever finds the URL. See private apps for how tokens work.
Run it in Europe
Dockhold runs on infrastructure in Germany. If keeping your stack in the EU matters to you, your MCP server, the app it serves, and its database can all live there together. The details are on the security and trust page.
Put your MCP server online
Bring the repository, or deploy the folder you already have.
Prefer to start from working code? The MCP server starter is a deployable repo, and Templates has the rest.