Self-hosting

Export your code and database and run your Floot app on your own infrastructure.

You own your Floot app's code and data. If you want to host it yourself, you can export the code and the database and deploy them wherever you like.

Code download is checked against your own plan

Choosing Get Code on a free account opens the upgrade dialog instead of the zip. The check is against the account you are signed in as, not the project owner's — so on a project someone shared with you, you need a paid plan of your own even when the owner has one.

Exporting happens in your browser

The zip is built in the browser, so there is no export tool over MCP — you cannot ask your AI assistant to produce it. Open the project on floot.com and use the project name dropdown in the top-left. From an MCP client the closest equivalents are read_files for source and pull_database_schema / query_database for the database.

When to self-host

You need to meet specific compliance or data residency requirements
You want full control over your infrastructure
You are migrating away from Floot
You need to run the app in an air-gapped environment

What you can export

Asset	How to export
Code	Project name dropdown → Get Code (paid plan required)
Database	Services tab → Data → Floot database → cog icon → Export → Download Database (a gzipped `pg_dump`, `.sql.gz`; any plan and any size, not while the hosting balance is unpaid). Tick Structure only for the tables, indexes and functions without the rows
Uploaded files	Not in the code zip, and there is no bulk download. Services → Storage lists them: click a file to preview it, or Download to save it, one file at a time, whatever its type and whether it is public or private. To move many files, have your assistant copy them to your new storage while the app is still on Floot

The zip is your project as it stands now, the same code the preview runs. It is not a copy of what was last published, and it holds no checkpoints or history.

Planning to leave?

Download your database while your hosting balance is still positive. Once the balance runs out, the database can't be exported until it is paid, even before your apps are taken down.

That is the whole export. The code zip is your source, not a complete copy of the running app, so plan for four things that do not travel with it:

Your API keys. env.json lists the variables your app expects but leaves each secret as ... fill this up ... — you supply the values.
Images and files in Floot's storage. Anything from generate_image or upload_asset lives in the project's hosted storage and is served from the app's own domain, so the exported code still points at URLs you no longer host. Re-upload those files to your own storage and update the paths.
The built-in Floot services. Anything your code imports from @floot/… — see the table below. These are a hard build break, not a missing extra.
Example documents. The .example.tsx and .__example.tsx files (and their stylesheets) that sit beside components and pages are development-only and are skipped by the zip. Nothing that ships depends on them.

How to self-host

1
Export your code
Open your project on floot.com, click the project name dropdown, choose Get Code, and download the zip. The zip is built in your browser, so give it a moment on a large project.
2
Export your database
Open the Services tab, click Data, select Floot database and open a table, then click the cog icon in the table header and choose Export → Download Database. The export runs in the background (a large database can take a while, and you can close the dialog meanwhile); when it is ready, Download gives you a gzipped pg_dump file (.sql.gz), available for 24 hours.
3
Set up your own database
Restore the file into a PostgreSQL database you control (gunzip -c database-dump.sql.gz | psql <connection string>), then note its connection string. The dump carries no owners or grants, so it loads under whatever user you connect as. Managed options like Supabase, Neon, AWS RDS, or Railway all work.
4
Configure environment variables
The exported code includes an env.json file. For security it is not pre-populated — you supply the values.
JWT secrets — generate one with:
```
node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
```
Database connection — fill in your own PostgreSQL connection string. Floot's database is not reachable from self-hosted environments.
External services — paste in the API keys for any third-party services your app uses.
5
Build and run
The export is a Node.js application:
```
npm install -g pnpm
pnpm install
pnpm vite build
pnpm tsx server.ts
```
Adjust freely to fit your own framework or deployment target.

Floot-managed services

Some built-in services are injected by Floot's build and are not included in the export. Any @floot/* import left in your code will fail to resolve, so the exported project does not build until you replace them — this is a hard build break, not a degraded feature. Migrate off these before you export: ask your AI assistant to do it while the project is still on Floot, then export.

Service	What to do instead
Floot OAuth	Configure your own auth provider
Floot Storage	Migrate to an object storage provider like Cloudflare R2, S3, or Cloudinary
Floot AI	Use your own API key with the AI provider of your choice
Floot Realtime	Use a pub/sub service (Pusher, Ably, Redis pub/sub) or drop the feature
Floot Email	Point the app at your own provider — Resend, SendGrid, Postmark, SES
Scheduled & background jobs	Run them with your platform's scheduler (cron, EventBridge, a queue worker)
Floot Push	Generate your own VAPID keypair and send notifications with a web-push library — Floot mints the keypair for you and it does not travel with the export
Floot runCode	Run the code in your own sandbox or worker process
Floot Payments	Use Stripe directly with your own keys and webhooks
Floot Shipping	Call Shippo directly with your own API key
Connected apps	Have one app call the other over HTTPS, with your own API key between them
Signed-in Floot user (private apps)	Give the app a login of its own
Fixed outbound IP	Use your host's own static outbound IP
Google and Microsoft integrations	Register your own OAuth app with each provider and manage the tokens yourself
Microsoft login	Configure your own Entra ID app registration
Pre-rendering (server-side rendering)	The exported server sends the same `index.html` for every page and renders in the browser, even if Enable Pre-rendering was on in Floot. Build your own server rendering if you need it

Moving a live app

If people are using the app while you move it, do the move in this order so nothing is written to the old database after you copy it.

Get the exported code building and running on your own host first, against a test database.
Stop new writes: remove any custom domain from the Floot project, then unpublish the app. The project, its database and its stored files stay intact.
Export the database and restore it on your side. The export is one pg_dump, so it is a single consistent snapshot of the data.
Point your domain's DNS at the new host.

Two things your users will notice. Because you generate a new JWT secret, everyone signs in again. And anyone who connected a Google or Microsoft account through Floot's built-in integration connects it again through the OAuth app you registered.

Things to consider

API keys: You will need to set up your own keys for every third-party service.
Updates: Self-hosted apps do not receive updates from Floot. Maintaining the code is on you.
Support: Floot support covers the Floot platform, not self-hosted deployments.