# Migrate from Replit to Sandboxer > 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. Source: https://sandboxer.com/migrate/replit. Updated 2026-10-27. **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](/docs/machines)) | | `.replit` `run` command, or a [Workflow](https://docs.replit.com/features/workspace-tools/workflows) | A systemd service, or `sbx exec --detach` ([Long-running](/docs/long-running)) | | `replit.nix` `deps` and `.replit` `modules` ([Configuration](https://docs.replit.com/features/project-setup/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](https://docs.replit.com/core-concepts/project-editor/app-setup/secrets)) | `-e KEY=value` per sandbox, or an environment for every sandbox ([Environments](/docs/environments)) | | `[[ports]]`: first port on external 80, a fixed list of extra ports ([Ports](https://docs.replit.com/features/project-setup/ports)) | `sbx host `: `https://-.box.sandboxer.com` for any port ([Hosting](/docs/hosting)) | | SSH with an account key, `Host *.replit.dev`, on Core, Pro and other paid plans ([SSH](https://docs.replit.com/features/workspace-tools/ssh)) | `sbx ssh`, or `sbx ssh-config` for any OpenSSH tool, on every plan ([SSH](/docs/ssh)) | | Checkpoints and rollbacks made as Agent works | Snapshots on every stop, and named snapshots you start new sandboxes from ([Snapshots](/docs/snapshots)) | | Remix an app: your own copy of a public app | `sbx new --from ` for a named snapshot, or `sbx fork ` | | 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](https://docs.replit.com/features/publishing/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](/docs/cli), [REST API](/docs/api) and [Python SDK](/docs/sdk-python). | On Replit | `sbx` CLI | REST / SDK | | - | - | - | | Create a Repl, or Remix one | `sbx new --setup-file ./setup.sh`, `sbx new --from ` | `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 `, `sbx exec "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 5000 [--public]` | `sb.host(5000, public=True)` | | Add an SSH key, connect from VS Code | `sbx ssh-config --install`, then `ssh .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 `, `sbx new --from ` | `sb.snapshot("name")`, `client.create(from_="name")` | | Stop the Repl | `sbx stop `, then `sbx resume ` | `sb.stop()`, `sb.resume()` | | Delete the Repl | `sbx delete --yes` | `sb.delete()` | ## Before and after From Replit's docs: [https://docs.replit.com/features/project-setup/configuration](https://docs.replit.com/features/project-setup/configuration) (the default Python `.replit`, and the `replit.nix` example, checked on 2026-10-27): ```toml entrypoint = "main.py" modules = ["python-3.10:v18-20230807-322e88b"] [nix] channel = "stable-23_05" [deployment] run = ["python3", "main.py"] deploymentTarget = "cloudrun" ``` ```nix { 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](https://github.com/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: ```bash #!/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: ```bash sbx new --name aeo-migrate-replit-3 --type small --setup-file ./setup.sh ``` ```text {"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`: ```bash 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}' ``` ```text {"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: ```bash sbx exec sb_xs9y37dmuc 'cd ~/app && .venv/bin/python --version && systemctl is-active app && curl -s localhost:5000 | grep -o "[^<]*"' sbx host sb_xs9y37dmuc 5000 --public curl -s https://chief-funny-spruce-5000.box.sandboxer.com | grep -o '[^<]*' ``` ```text Python 3.11.17 active Yahoo Finance API Documentation {"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} Yahoo Finance API Documentation ``` `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 `.sbx`. That includes VS Code Remote-SSH, Cursor and `rsync`. You don't need to manage keys: ```bash 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/ ``` ```text 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: ```bash 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](https://docs.replit.com/help/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: ```bash sbx scp ./project.zip :/home/user/ sbx exec "unzip -q project.zip -d app" sbx scp -r ./project :/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](/docs/long-running#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 --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](/docs/environments)). Replit keeps workspace and deployment secrets apart. Here, a separate named environment (`sbx new --environment `) 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 --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](https://docs.replit.com/teams/identity-and-access-management/manually-copy-projects)). 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](/guides/test-text-to-sql-queries-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](/docs/snapshots#resume)). - **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](/docs/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](/docs/hosting#custom-domains)). 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](/docs/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](https://docs.replit.com/billing/deployment-pricing), checked on 2026-10-27, and its [pricing page](https://replit.com/pricing), checked on 2026-10-24. Ours come from [/pricing](/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 `.sbx` with Remote-SSH ([SSH from VS Code or Cursor](/guides/ssh-into-a-cloud-sandbox-from-vs-code-or-cursor)). ## Related - [Sandboxer vs Replit](/compare/replit) - [Quickstart](/docs/quickstart) - [Long-running tasks and setup scripts](/docs/long-running) - [Turn a sandbox into a reusable template](/guides/turn-a-sandbox-into-a-reusable-template)