Migrate from Replit to Sandboxer

Q: How do I get my code out of Replit?

Replit's help says to use Download as zip in the file tree, or run zip -r project.zip . in the Shell. If a workspace admin has turned on the setting that bans source code export, the zip download is blocked, so ask them first.

Q: Is there something like Replit Deployments?

Not as a product. A sandbox with --no-auto-stop and a public hosted port serves an app around the clock, billed per second. There's no autoscaling or static hosting.

Q: Can I open the sandbox in VS Code or Cursor like Replit's SSH feature?

Yes. Run sbx ssh-config --install once, then connect to .sbx with Remote-SSH (SSH from VS Code or Cursor).

Updated October 27, 2026 .md Sandboxer vs Replit

Short answer: Download your Repl as a zip or push it to GitHub. Then turn its .replit run command and replit.nix packages into a setup script for sbx new --setup-file. Host the port for an HTTPS URL, SSH in with sbx ssh-config, and save a named snapshot to reuse. Replit's editor, Agent, Deployments and database don't move.

This page is for developers who build on Replit and now want a full Linux VM that their own agents, scripts or CI drive. On Sandboxer you get root through sudo, Docker, /dev/kvm, SSH, a CLI and a REST API. You don't get a browser IDE, an AI app builder or managed hosting. If you build and publish apps from a prompt, Replit is built for that, and you may want to stay.

Concept map#

Facts about Replit come from its docs, linked in each row, checked on 2026-10-27.

Replit	Sandboxer
Replit App (Repl): a project with an editor, a shell and a preview	Sandbox: an Ubuntu 24.04 microVM with its own kernel, `sudo`, systemd and Docker (Machines)
`.replit` `run` command, or a Workflow	A systemd service, or `sbx exec --detach` (Long-running)
`replit.nix` `deps` and `.replit` `modules` (Configuration)	Pre-installed Node.js 22, Python, `uv`, Go and Rust, plus `apt`, `pip`, `npm -g` in a setup script
Secrets tool; deployment secrets kept apart (Secrets)	`-e KEY=value` per sandbox, or an environment for every sandbox (Environments)
`[[ports]]`: first port on external 80, a fixed list of extra ports (Ports)	`sbx host <id> <port>`: `https://<slug>-<port>.box.sandboxer.com` for any port (Hosting)
SSH with an account key, `Host *.replit.dev`, on Core, Pro and other paid plans (SSH)	`sbx ssh`, or `sbx ssh-config` for any OpenSSH tool, on every plan (SSH)
Checkpoints and rollbacks made as Agent works	Snapshots on every stop, and named snapshots you start new sandboxes from (Snapshots)
Remix an app: your own copy of a public app	`sbx new --from <name>` for a named snapshot, or `sbx fork <id>`
Built-in SQL database (`DATABASE_URL`)	No managed database. Run Postgres in Docker inside the sandbox, or keep a hosted one
Publishing: Autoscale, Reserved VM, Static, Scheduled (Deployment types)	No deployment product. A sandbox with auto-stop off and a hosted port stays up

API and SDK mapping#

The Replit docs we checked don't describe a public API for creating and running Repls; its Enterprise Admin API covers usage, workspaces, members and projects. So this table maps what you do in the Replit workspace to the call that does it here. Our side is from the CLI, REST API and Python SDK.

On Replit	`sbx` CLI	REST / SDK
Create a Repl, or Remix one	`sbx new --setup-file ./setup.sh`, `sbx new --from <name>`	`POST /sandboxes` with `setupScript` or `from`; `client.create(setup_script=...)`
Press Run	`sudo systemctl enable --now app` in the setup script	`sb.start("...")` for a background command
Open the Shell tab	`sbx ssh <id>`, `sbx exec <id> "cmd"`	`sb.exec("cmd")`
Add a secret in the Secrets tool	`sbx new -e KEY=value`, `sbx env set-var base KEY=value`	`env={...}` on create, `POST /secrets`
Add a port in Networking	`sbx host <id> 5000 [--public]`	`sb.host(5000, public=True)`
Add an SSH key, connect from VS Code	`sbx ssh-config --install`, then `ssh <id>.sbx`	`POST /sandboxes/{id}/sshkey`
Download as zip, upload files	`sbx scp`, `sbx scp -r`	`sb.files.read`, `sb.files.write`
Roll back to a checkpoint	`sbx snapshot <id> <name>`, `sbx new --from <name>`	`sb.snapshot("name")`, `client.create(from_="name")`
Stop the Repl	`sbx stop <id>`, then `sbx resume <id>`	`sb.stop()`, `sb.resume()`
Delete the Repl	`sbx delete <id> --yes`	`sb.delete()`

Before and after#

From Replit's docs: https://docs.replit.com/features/project-setup/configuration (the default Python .replit, and the replit.nix example, checked on 2026-10-27):

entrypoint = "main.py"
modules = ["python-3.10:v18-20230807-322e88b"]

[nix]
channel = "stable-23_05"

[deployment]
run = ["python3", "main.py"]
deploymentTarget = "cloudrun"

{ pkgs }: {
  deps = [
    pkgs.nodejs-19_x
    pkgs.yarn
  ];
}

On Sandboxer those two files become one shell script. To test it, we used a public Repl that Replit Agent built: derekcheungsa/yfinance-wrapper, a Flask app (Apache-2.0). Its .replit sets modules = ["python-3.11"], a workflow that installs packages and runs python main.py with waitForPort = 5000, and [[ports]] localPort = 5000. Its replit.nix has one dep, pkgs.glibcLocales. Each line of setup.sh maps to one of those:

#!/bin/bash
set -e
# replit.nix: deps = [ pkgs.glibcLocales ]  ->  apt
sudo apt-get update -qq && sudo apt-get install -y -qq locales
# Your exported Repl (here, a public Agent-built Flask app)
git clone --depth 1 https://github.com/derekcheungsa/yfinance-wrapper ~/app
cd ~/app
# .replit: modules = ["python-3.11"] and packager.installForAll  ->  uv
uv venv --python 3.11 .venv
uv pip install --python .venv/bin/python -q -r requirements.txt
# .replit workflow: python main.py, waitForPort = 5000  ->  a systemd service
sudo tee /etc/systemd/system/app.service >/dev/null <<'UNIT'
[Unit]
Description=Exported Repl
After=network-online.target
[Service]
User=user
WorkingDirectory=/home/user/app
ExecStart=/home/user/app/.venv/bin/python main.py
Restart=always
[Install]
WantedBy=multi-user.target
UNIT
sudo systemctl daemon-reload
sudo systemctl enable --now app

We ran the rest on prod on 2026-10-27. Create the sandbox with the script. sbx new returns at ready, and the script keeps running in the background:

sbx new --name aeo-migrate-replit-3 --type small --setup-file ./setup.sh

{"event":"created","id":"sb_xs9y37dmuc","state":"provisioning","subdomain":"chief-funny-spruce","setupStatus":"pending"}
{"event":"ready","id":"sb_xs9y37dmuc","state":"ready","subdomain":"chief-funny-spruce","setupStatus":"running"}

Wait for the setup to finish. Poll setupStatus until it's done or failed:

until s=$(sbx info sb_xs9y37dmuc --json | jq -r .sandbox.setupStatus); [ "$s" = done ] || [ "$s" = failed ]; do sleep 10; done
sbx info sb_xs9y37dmuc --json | jq -c '.sandbox | {setupStatus, setupError}'

{"setupStatus":"done","setupError":null}

In this single run, the sandbox was ready 3.2 seconds after the create, and the setup was done within the next 10 seconds. Check that the app runs, then host its port:

sbx exec sb_xs9y37dmuc 'cd ~/app && .venv/bin/python --version && systemctl is-active app && curl -s localhost:5000 | grep -o "<title>[^<]*</title>"'
sbx host sb_xs9y37dmuc 5000 --public
curl -s https://chief-funny-spruce-5000.box.sandboxer.com | grep -o '<title>[^<]*</title>'

Python 3.11.17
active
<title>Yahoo Finance API Documentation</title>
{"ok":true,"type":"port.hosted","sandboxId":"sb_xs9y37dmuc","port":5000,"url":"https://chief-funny-spruce-5000.box.sandboxer.com","access":"public","isProtected":false,"localhost":false}
<title>Yahoo Finance API Documentation</title>

uv downloaded Python 3.11 to match the modules line, even though the image ships a newer python3. Leave out --public and the URL is private, with a _token in it.

SSH, root, Docker and KVM#

sbx ssh-config prints an SSH config block. Add it to ~/.ssh/config (or run sbx ssh-config --install), and any OpenSSH tool reaches a sandbox as <id>.sbx. That includes VS Code Remote-SSH, Cursor and rsync. You don't need to manage keys:

sbx ssh-config --install
ssh sb_xs9y37dmuc.sbx 'whoami; sudo whoami; uname -r; docker --version; sudo docker run --rm hello-world | grep Hello; ls -l /dev/kvm'
rsync -a sb_xs9y37dmuc.sbx:app/api/ ./api-back/

user
root
6.18.56-sandboxer
Docker version 29.9.0, build f415da8
Hello from Docker!
crw-rw---- 1 root kvm 10, 232 Oct 27 03:02 /dev/kvm

The rsync exited 0 and copied the app's api/ folder back. We ran these with the printed config passed to ssh -F and rsync -e, which works the same as installing it.

Save it and start from it#

Save the configured disk under a name. New sandboxes start from it with the packages installed and the service enabled, and they skip the setup script:

sbx snapshot sb_xs9y37dmuc replit-app
sbx new --from replit-app --type small

On this run, the snapshot came back "status":"ready" in 2.1 seconds. We then deleted the sandbox and the snapshot without starting a sandbox from it. The sbx new --from step was tested on a different repo: earlier the same night (2026-10-27, single run) we saved a snapshot the same way from a sandbox running a Node app, remix-run/remix-replit-template, and started sb_8fvr4x78e7 from it. It was ready in under 3 seconds. The cloned app and its node_modules were there, setupStatus was null because no script ran again, and systemctl is-active app printed active with no extra step. That template's own dev server failed to start on Node 22 and on Node 18 for reasons inside the template, which is why we switched repos for the run above. A sandbox started from a named snapshot boots fresh from disk. That's why the setup script makes the app a systemd service instead of a one-off command.

Move your data and environment#

Code and files. Replit's docs give two ways out: the file tree's Download as zip, or zip -r project.zip . in the Shell (Projects and files). You can also connect the Git pane to GitHub and push. Then either clone in the setup script, as above, or copy the zip in:

sbx scp ./project.zip <id>:/home/user/
sbx exec <id> "unzip -q project.zip -d app"
sbx scp -r ./project <id>:/home/user/      # a folder, sent as one tar stream

Replit hides .replit and replit.nix by default. They come along in the zip, and you can delete them once your setup script replaces them.

replit.nix and modules. Nix packages don't install here. Map each one: pkgs.nodejs-* to the pre-installed Node.js 22, pkgs.python3* to uv venv --python 3.x, pkgs.yarn to npm install -g yarn, and system libraries to sudo apt-get install. If your app pins an old runtime, test it on the version you install. To skip the installs on every new sandbox, run the script once and save a named snapshot. A setup script can be up to 64 KB (Setup scripts).

Run command and Workflows. A run line or a Workflow task becomes a systemd service, so the app starts again after a cold boot or a start from a snapshot. For a one-off job, use sbx exec <id> --detach "cmd". If a workflow starts several processes, give each one its own unit or use docker compose.

Secrets. Replit doesn't copy secrets with a project. Set them again here. Use sbx new -e KEY=value for one sandbox. For values every new sandbox should get, use sbx env set-var base KEY=value (Environments). Replit keeps workspace and deployment secrets apart. Here, a separate named environment (sbx new --environment <name>) plays that role.

Ports. Replit maps your first port to external port 80 and offers a fixed list of extra ports. Here, every port gets its own HTTPS subdomain, so 5000 stays 5000. If the server listens on 127.0.0.1 only (Replit's exposeLocalhost), use sbx host <id> <port> --localhost.

Database. Replit's guide moves data with pg_dump -Fc "$DATABASE_URL" --no-owner --no-privileges -f backup.dump in the Shell (Manually copy a project). The dump file works with any Postgres. Restore it into a hosted Postgres you point DATABASE_URL at, or into Postgres in Docker inside the sandbox (see test SQL against a real Postgres). We didn't run a Replit database export for this page.

What's different#

What you gain:

A machine your code drives. Create, run, host, snapshot and delete through the CLI, the REST API, or the Python and TypeScript SDKs. On Replit, the editor, Agent and the Publishing tool are the main interface.
Root, Docker and KVM. In our run, sudo whoami printed root, docker run hello-world worked, and /dev/kvm was present. Replit's docs we checked don't describe root, Docker or nested virtualization in a Repl.
Stop with memory. sbx stop saves memory and disk, and a resume brings back running processes. If the resume lands on a machine with a different CPU type, the sandbox boots from disk instead: files are kept, processes aren't (Snapshots).
SSH on every plan. Replit lists SSH for Core, Pro and other paid plans.
Any port. Each port gets its own HTTPS URL, not one from a fixed list.

What you lose or must change:

The browser IDE, Agent and collaboration. There's no hosted editor with multiplayer and no AI app builder. Use your own editor over SSH, and run coding agents like Claude Code or Codex inside the sandbox (Agents).
Deployments. There's no Autoscale, Static or Scheduled deployment, and no first-class custom domains (you can point a CNAME and terminate TLS yourself, per Hosting). A sandbox with --no-auto-stop and a hosted port serves traffic, but it doesn't scale out.
The built-in database. Bring your own Postgres, as above.
Nix. Packages come from Ubuntu's apt, language package managers and the pre-installed tools.
Forks copy disk only. sbx fork copies the disk as it is now. The fork boots fresh, so hand-started processes don't come with it; systemd services do.
Fixed sizes. There are four sizes, from small (2 vCPU, 4 GB) to xlarge. You can grow a sandbox at resume time. Moving to a smaller size isn't supported yet: to go smaller, create a new sandbox of that size and copy your files, so start small and grow.
Regions. Sandboxer has two regions, us-east (Ashburn, Virginia) and eu-central (Helsinki, Finland); see regions. Replit's deployment docs list United States hosting, with EU hosting on request for Enterprise (checked 2026-10-24).

Pricing#

Replit's prices come from its deployment pricing docs, checked on 2026-10-27, and its pricing page, checked on 2026-10-24. Ours come from /pricing.

Usage	Replit	Sandboxer
Plan	Core $20/month, Pro $100/month, with monthly credits	From $20/month, paid back as machine time
Always-on 2 vCPU, 8 GB	Reserved VM: $50/month	Nearest size, `default` (4 vCPU, 8 GB): $0.036/hour, $26.28 for 730 hours
Always-on 4 vCPU, 16 GB	Reserved VM: $130/month	Nearest size, `large` (8 vCPU, 16 GB): $0.072/hour, $52.56 for 730 hours
Always-on 1 vCPU, 4 GB	Reserved VM: $35/month	Nearest size, `small` (2 vCPU, 4 GB): $0.018/hour, $13.14 for 730 hours
Idle	Autoscale: $2/month base, $0.60 per million compute units, $0.40 per million requests	A stopped sandbox isn't billed; its disk counts toward included storage (50 GB on the $20 plan)

The sizes don't line up exactly, so the table pairs each Replit VM with our nearest size. Replit's monthly credits apply to these costs. Data transfer on Reserved VMs is $0.05 per GB. We bill per second while a sandbox runs. Autoscale fits traffic that comes and goes, and it has no direct counterpart here. Sandboxer has a 7-day trial with 25 hours, and it needs a card.

FAQ#

Can I keep developing on Replit and run agents on Sandboxer?#

Yes. Connect the Repl to GitHub, and have a setup script clone the repo into each new sandbox. Your agents get a full VM with Docker and root, and the Repl stays as it is.

What happens to my `.replit` and `replit.nix` files?#

Nothing reads them here. Map them into a setup script once: run and Workflows become a systemd service, [[ports]] becomes sbx host, and Nix deps become apt, uv, pip or npm installs.

How do I get my code out of Replit?#

Replit's help says to use Download as zip in the file tree, or run zip -r project.zip . in the Shell. If a workspace admin has turned on the setting that bans source code export, the zip download is blocked, so ask them first.

Is there something like Replit Deployments?#

Not as a product. A sandbox with --no-auto-stop and a public hosted port serves an app around the clock, billed per second. There's no autoscaling or static hosting.

Can I open the sandbox in VS Code or Cursor like Replit's SSH feature?#

Yes. Run sbx ssh-config --install once, then connect to <id>.sbx with Remote-SSH (SSH from VS Code or Cursor).

All migration guides