Which Python frameworks are supported?

Django, Flask, and FastAPI are first-class. Django is detected from manage.py; Flask and FastAPI are detected from your dependencies. Anything WSGI or ASGI that these cover will run. When you connect a repo we set the install and start commands for you, and you can override them.

Which Python version can I run?

Python 3.13, 3.12, or 3.11. We recommend 3.12. Set it in the build settings, or let us read it from .python-version, the requires-python field in pyproject.toml, or runtime.txt.

What web server runs my app?

Django and Flask are served with Gunicorn; FastAPI is served with Uvicorn for async workloads. These are configured automatically based on the framework we detect, and you can adjust the command if you need specific worker counts or timeouts.

How are dependencies installed?

From your requirements.txt (or Pipfile). Builds run on a slim Python base image with glibc, so packages that ship compiled wheels - think numpy, Pillow, or database drivers - install cleanly without extra work.

Does collectstatic and migrate run for Django?

Yes. The default Django build installs requirements, runs collectstatic, and applies database migrations before the app starts. You can change the install command if your project needs a different order.

What port does my app need to bind to?

Bind to 0.0.0.0 on the port provided in the PORT environment variable (8000 by default for Python). Gunicorn and Uvicorn both take the bind address on the command line, which we set for you. Binding to localhost is the most common reason an app builds but won’t start.

Can my app talk to a MySQL database?

Yes. Your database host is injected into the container as an environment variable, and you connect over TCP with the credentials you manage in the panel. Add your own DATABASE_URL or individual settings as environment variables too.

Is Python hosting included in my plan?

Yes. Git deployment, container hosting, rollback, live logs, and environment management are part of every plan. A Python app runs in a container that counts against your plan’s app allowance.

Python

Django, Flask, and FastAPI - deployed from Git

Connect a repository and push. We detect your framework, build on a slim Python image, and run it under Gunicorn or Uvicorn in an isolated container - health-checked, and rolled back in one click when you need it.

Start free trial See pricing

14 days free. No credit card. No commitment.

Push to deploy

GitHub, GitLab, Bitbucket

Gunicorn / Uvicorn

Configured for you

One-click rollback

Promote any build

14-day free trial

No credit card required

99.9% uptime SLA

Container isolation

Using an AI coding assistant?

Point it at the plain-text build guide so it configures your deploy correctly. It is the same contract our docs describe, formatted for machines.

Deploying a specific stack?Node.js Nuxt Python Ruby Static & SPA Build guide

$ curl https://www.hostney.com/build-guide.txt

Pricing

Simple, transparent pricing

Every plan includes managed WordPress, SSH access, daily backups, and enterprise-grade security. Start with a 14-day free trial.

Startup

Great for growing businesses

$7.99/mo

$94.99 billed annually

Get started

1 website
10 GB storage
~10,000 visits/month
5 MySQL databases
250,000 inodes
5 FTP users

What's included:

SSL & Domain

Free SSL certificate
Free starter domain

Apps & CMS

1-click WordPress
Managed WordPress
WordPress staging

Advanced

For professional websites

$14.99/mo

$179.99 billed annually

Choose plan

5 websites
20 GB storage
~110,000 visits/month
10 MySQL databases
500,000 inodes
10 FTP users

Everything in Startup, plus:

Backups

14 days of backup history

Performance

Memcached

Pro

Maximum performance and features

$22.99/mo

$274.99 billed annually

Go pro

10 websites
40 GB storage
~200,000 visits/month
20 MySQL databases
750,000 inodes
20 FTP users

Everything in Advanced, plus:

Deployment

2 SSR applications

Backups

30 days of backup history

Compare plans

Frameworks

Detected from your project, served correctly

We look at your code - manage.py, your dependencies - decide which framework you’re running, and wire up the right server command.

Django

WSGI

Detected from manage.py. We install your requirements, collect static files, run migrations, and serve with Gunicorn.

$ gunicorn project.wsgi --bind 0.0.0.0:$PORT

Flask

WSGI

Detected from your dependencies. We find your app object and run it under Gunicorn with sensible worker defaults.

$ gunicorn app:app --bind 0.0.0.0:$PORT

FastAPI

ASGI

Detected from your dependencies. We locate your ASGI app and serve it with Uvicorn for full async support.

$ uvicorn app:app --host 0.0.0.0 --port $PORT

Every command is a starting point - change worker counts, timeouts, or the entry module in your build settings anytime.

What you get

A real deployment pipeline, built in

Connect a repository once and every push runs through the same build, health-check, and promote pipeline - with rollback always one click away.

Git push deploys

GitHub, GitLab, or Bitbucket over OAuth or a token. A push registers a webhook and triggers a build automatically.

Framework detection

Django, Flask, or FastAPI recognized from your project. Install and start commands set for you, fully overridable.

Slim Python image

Builds run on a glibc-based slim image, so compiled wheels like numpy and Pillow install without a fight.

MySQL ready

Your database host is injected into the container. Connect over TCP with credentials you manage in the panel.

Blue/green deploys

A new build starts on a fresh port and only takes traffic after a health check passes. A failed build never reaches visitors.

One-click rollback

Every successful build is kept. Promote a previous one back to live in seconds - no rebuild, no Git revert.

Env vars & secrets

Build-time and runtime variables in the panel. Mark any as a secret and the value is sealed - write-only, never shown again.

Live logs

Stream your app output and platform events straight from the panel. See tracebacks and restarts without SSH.

How it works

Push. Build. Live.

Three Git providers, one pipeline. Choose ship-on-every-push, or build-and-hold until you promote it yourself.

Connect your repository

Link GitHub, GitLab, or Bitbucket via OAuth or a token, pick the repo and branch, and a push webhook is registered for you.

We detect and build

Each push clones the commit, detects Django, Flask, or FastAPI, installs your requirements on a slim Python image, and packages a versioned container image.

Health-check and promote

The container has to answer on its port within 30 seconds before it goes live. On Auto deploy it promotes itself; on Build only it waits for you.

Build #v12

Current

Repositoryapi-service / main

FrameworkFastAPI

Python3.12

Port8000

Build log

✓ Detected FastAPI

✓ pip install -r requirements.txt

✓ Image built (python:3.12-slim)

✓ uvicorn bound 0.0.0.0:8000

✓ Health check passed · promoted

Databases, right where you expect them

Create MySQL databases and users in the panel, then reach them from your container over TCP. The database host is injected for you, and phpMyAdmin is one click away for browsing.

See the developer tooling

Ship it

Deploy your Python app in minutes

Connect a repo, push, and watch it go live under Gunicorn or Uvicorn. Included in every plan. Start free for 14 days, no credit card.

Start your free trial

Questions