How to export your code from Base44, and what the export leaves out
Base44 gives you three official ways to take code out and one way to take data out. None of them gives you an app that runs without Base44. Here is what each one contains, when to use it, and what the rest takes.
Updated 13 min readBy the Unbase44 team
On this page
- 01The short version
- 02Option 1: download the project as a ZIP
- 03Option 2: two-way GitHub sync
- 04Option 3: the Base44 CLI and base44 eject
- 05Option 4: export your data as CSV
- 06Exporting on the Free plan
- 07What the exports leave behind
- 08Why exported code still calls Base44
- 09Your realistic options
- 10A checklist before you export anything
- 11Questions and answers
- 12Sources
The short version
Base44 offers four official ways to take things out of an app:
- Download the project as a ZIP from the Code tab. You get the frontend project, including your function files and table definitions.
- Two-way GitHub sync. The same code, kept in a repository you choose and updated automatically.
- The Base44 CLI, including
base44 eject, which copies an app into a new, separate Base44 project with an empty database. - CSV export, one table at a time, from the Data dashboard.
The first two need the Builder plan or higher. All four are useful, and none of them produces an app that runs without Base44. The code they give you is a client for Base44’s servers: sign-ins, records, functions, emails and AI calls all still go to Base44. The rest of this article explains each option in detail, what you can do on the Free plan (including the browser extensions that promise a free download), and what it takes to get the parts the exports leave behind.
To run the app without Base44, its backend has to come too. You can rewrite the app for another backend such as Supabase, or move the same app onto a Base44-compatible backend you own, which is what a migration tool like Unbase44 does, with your records, users and their passwords. Your realistic options compares them.
Free tool: the Base44 export checker reads your export in the browser and lists everything that still runs on Base44’s servers. Nothing is uploaded. It’s also open source on GitHub, as a command-line tool with a checklist for leaving Base44.
Option 1: download the project as a ZIP
Open your app, go to Code, and click the Export project as ZIP icon at the top right of the code view. Base44’s developer tools page notes that both the ZIP download and the GitHub connection require a Builder plan or higher.
The archive is a standard React app built with Vite. According to Base44’s project structure docs it contains:
src/pages, one file per route (Home.jsxbecomes/,Settings.jsxbecomes/settings)src/components, including aui/folder of pre-built componentssrc/api, the Base44 SDK client configurationsrc/hooks,src/libandsrc/utilsentities/, one JSON schema file per tablefunctions/, one TypeScript file per backend functionpackage.json(which includes@base44/sdk),vite.config.jswith the Base44 Vite plugin, a Tailwind config andindex.html
Base44’s project structure page says you can run it with npm install and npm run dev. What you will see is your app’s interface, talking to Base44’s backend. The data it shows is your live data, served by Base44.
When the ZIP is the right tool: a backup of your code, a handover to a developer who wants to read it, or a snapshot before a risky round of AI edits.
Option 2: two-way GitHub sync
Connecting GitHub keeps your app’s code in a repository and syncs changes both ways. Base44’s GitHub integration docs set out the rules, and a few of them matter if you’re thinking of this as an exit:
- It needs the Builder plan or higher, and only an app owner can make the first connection.
- Changes in Base44 are pushed to the repository automatically; there is no manual push.
- Changes you make locally reach Base44 when you merge them into a branch named
main. You still click Publish in Base44 to make them live. - Entities are managed in Base44 and aren’t in the repository, so your table definitions aren’t part of what syncs.
- Once connected, Version History can’t restore versions from before the connection, because those versions aren’t in the repository.
- You can disconnect and later reconnect the same repository, except in a few cases Base44 lists: both the app and the repository have new commits since they last matched; the repository was renamed, deleted or had its default branch changed; or it was connected from a different workspace. Then you start a new repository instead.
GitHub sync is a good way to let Claude Code, Cursor or a developer work on the code without leaving Base44. It gives you a durable copy of your code. It doesn’t move where the app runs.
Option 3: the Base44 CLI and base44 eject
The Base44 CLI (npm install -g base44@latest) has two commands people reach for when they want out.
base44 eject copies an existing Base44 app into a separate local project, as the eject reference describes it. It downloads the frontend code, entity schemas and other backend resources, and creates a new backend project with its own app ID. The new project starts with an empty database: schemas are copied, data isn’t. Your original app is untouched, and the two are independent from then on. The new project is still a Base44 app, hosted by Base44.
base44 dev starts a local Base44 backend and your frontend’s dev server together, and sends the frontend’s API requests to that local backend (GitHub integration). Base44’s local development overview is precise about what runs where. On your machine: backend functions (in Deno, which you install separately), entity data in an in-memory database that is cleared when you stop the server, file uploads in a temporary folder, and email-and-password sign-in. Forwarded to your deployed app on Base44: Google and other social sign-ins, and built-in integrations such as sending email or AI generation. Automations don’t run locally.
There’s also base44 dev --remote, which runs only your frontend against the app’s live backend on Base44. Base44 warns that in this mode writes go to your live app’s production data. Either way, it is a development tool, not a way to host the app.
Option 4: export your data as CSV
In the dashboard, open Data, select a table, click More actions, then Export. You get that table as a CSV file (Managing your app data).
Three details are worth knowing before you rely on this:
- One table at a time. An app with twenty tables means twenty exports, and relationships between them are just IDs stored in fields. Keep the IDs when you move the data, or those links break.
- The table view stops at 5,000 rows, the CSV doesn’t. Base44’s docs say the dashboard table shows up to 5,000 items, and recommend exporting to CSV to see everything.
- Users are a different matter. App users live in the Users section, and Base44’s own privacy documentation states that app users can’t be exported: when it describes cloning an app into another region, it says users will need to sign up again. Password hashes never leave Base44.
Going the other way is limited too: CSV imports into Base44 add new rows only and never update existing records.
Every route for your records, including tables over 5,000 rows and backups: how to export your Base44 database.
Exporting on the Free plan
On Free, your records are the one thing you can take out through the dashboard: the CSV export above works table by table. Every documented way to take the code out is listed with a Builder requirement: the ZIP download, GitHub sync, and reaching the app’s cloud sandbox from outside the editor, which fails with a “premium required” error below Builder.
That leaves three routes people look at.
Upgrade for a month, export, then downgrade
This is the documented route, and the cheapest is one month of Builder. As of October 2026, Builder costs $50 billed monthly or $40 a month billed yearly; Starter ($20 monthly) doesn’t include GitHub or the ZIP (pricing). Choose monthly billing. Base44’s terms treat yearly fees as non-cancellable and non-refundable.
- Upgrade. From your workspace settings, open Plan and billing and upgrade to Builder. Base44’s billing documentation says upgrades take effect as soon as you pay.
- Take everything you can. Connect GitHub (the repository is created in your own GitHub account), download the ZIP as well, and export every table to CSV. Write down your secrets’ names, your connectors and your domain’s DNS records while you’re there.
- Downgrade or cancel. A downgrade takes effect at the end of the current billing period, and so does a cancellation, so you keep Builder for the month you paid for. Cancelling doesn’t refund that month.
- Know what carries over. The ZIP and the repository are yours to keep. Base44 lists GitHub sync as a Builder feature, so don’t count on it continuing after the downgrade. Your apps stay live on Free, without the paid features.
One trap: once you’ve cancelled, you can’t buy the same plan again until the period ends. If you might need more time, hold off cancelling until you’re sure you have everything. Our guide to cancelling Base44 covers what stops working on Free.
base44 eject
The CLI’s eject reference doesn’t state a plan requirement. Even where it runs, it copies your code into a new Base44 project with an empty database, so it’s a copy on Base44 rather than a way out (see option 3 above).
“Downloader” and “code extractor” browser extensions
Search for a free Base44 export and you’ll find Chrome extensions, some in the Chrome Web Store and some published as source code on GitHub, that offer to download a project’s code as a ZIP. Base44’s documentation doesn’t mention any of them.
What they can get. An extension works with what your browser receives while you’re signed in to Base44. In practice that means the files the editor loads, or the text the code editor shows, file by file. At best that’s the same code the official ZIP contains: pages, components, entity schemas and function source. An extension that copies from the editor’s display can miss files, so compare what you get with the full file list in the Code tab.
What they can’t get. Anything Base44 doesn’t send to your browser: your users and their passwords, your secrets’ values (Base44 lets you set them but never shows them), the database itself beyond what you can already export, and the backend that runs sign-ins, functions, schedules and file storage. The code they produce is the same Base44 client as the ZIP, so it still needs Base44’s servers to run.
The risks are about your account, not your code:
- It acts as you. An extension allowed to read and change data on Base44’s site works inside your signed-in session, so it can do whatever you can do there, in every app you have access to. Google’s Chrome Web Store help explains these permission warnings: they don’t mean an extension is harmful, only that it could be.
- It can change after you install it. Chrome checks installed extensions for updates every few hours, so the code you trusted on day one isn’t necessarily the code running later.
- Base44’s terms have something to say. The terms of service ask you to keep your login credentials confidential and give account access only to people you trust, and they make you responsible for everything done under your account. The restricted-use section also forbids accessing the platform by automated means, such as crawling or scraping, other than through the interface Base44 provides, and forbids getting around measures that restrict access. Read those clauses before relying on a tool that does either.
If you try one anyway, use a separate browser profile, install it only for the export, and remove it straight afterwards. Turning on two-factor sign-in for your Base44 account is worth doing regardless.
What the exports leave behind
Put the four options together and this is where each part of your app ends up:
| Part of the app | In the ZIP or GitHub sync? | Where it actually lives |
|---|---|---|
| Frontend code | Yes | Your download or repo |
| Backend function code | Yes, as source files | Runs on Base44’s function runtime |
| Table definitions | In the ZIP; not in GitHub sync | Base44 |
| Records | No; CSV, one table at a time | Base44’s database |
| Users and passwords | No | Base44’s sign-in service |
| Secret values | No | Base44’s secrets store |
| Uploaded files | No; your records hold links to them | Base44’s file storage |
| Automations and workflows | The runner isn’t | Base44’s scheduler and event system |
| AI features and agents | Calls in your code | Base44’s integrations, billed in credits |
| Connectors (Gmail, Slack and so on) | No | OAuth tokens held by Base44 |
Why exported code still calls Base44
A Base44 frontend talks to its backend through the Base44 SDK. src/api creates a client with your app’s ID, and every data call in your pages, such as fetching a list of orders or saving a form, becomes an HTTP request to Base44’s API. Backend functions use the same SDK from the server side. Base44’s developer docs are explicit that integration calls always run on Base44 infrastructure, so your secrets never live in your frontend.
That design is why the export feels complete and isn’t. Every line of the app is there, but every line assumes Base44 answers on the other end. To run the code somewhere else you have two choices: rewrite every SDK call against a different backend, or run a backend that answers those calls the same way Base44 does.
Your realistic options
- Stay on Base44 and keep regular exports. Turn on GitHub sync (or download a ZIP after big changes) and export your important tables to CSV on a schedule. You own copies, not an independent app, but you’re protected against losing work.
- Rebuild on another stack. Supabase is the common choice; our guide to moving a Base44 app to Supabase lays out what that involves. Expect to rewrite the data layer, the security rules and the functions, and to ask every user to reset their password.
- Move the whole app to a Base44-compatible backend you own. This is what Unbase44 does. Your code goes into a private GitHub repo, your records into your own database, your files into your own storage, and a documented backend that speaks Base44’s API runs on your hosting. Users keep their passwords, and the app isn’t rewritten: its frontend gets only a few small patches, listed in the repository’s
docs/MIGRATION.md. Your code and that server arrive in your GitHub first, and nothing changes on Base44. Putting the app online on your own hosting is included in the price, now or later. The free analysis shows what your app contains and its one-time price before you connect anything or pay, and our guide to migrating from Base44 sets out the full order of a move.
A checklist before you export anything
- Check your plan: the ZIP and GitHub options need Builder or higher.
- Export every table to CSV and keep the files somewhere safe, whatever else you decide.
- Write down the names of your secrets (the values can’t be exported).
- List your connectors, automations or workflows, and anything your app sends by email.
- Note your custom domain’s DNS records, so you can point the domain elsewhere later.
- If you have paying users, note how payments reach your app (Stripe webhooks, for example), because those addresses change if the app moves.
Questions and answers
Can I export my Base44 app on the Free plan?
Your records, yes: the Data dashboard exports each table as a CSV. The code, not through any documented route. Base44 says downloading a ZIP and connecting GitHub both require the Builder plan or higher. The usual answer is one month of Builder on monthly billing, then a downgrade.
Can I downgrade to Free after exporting my code?
Yes. A downgrade or cancellation takes effect at the end of the billing period, so you keep Builder for the month you paid for. The ZIP and the GitHub repository stay yours afterwards. Base44 lists GitHub sync as a Builder feature, so expect the sync itself to stop on Free.
Are Base44 downloader or code extractor extensions safe?
They run inside your signed-in Base44 session, so they can do anything you can do in your account, and they can update themselves after you install them. At best they get the same code as the official ZIP; they can’t get users, passwords, secret values or the backend. Base44’s terms ask you to keep account access to people you trust and restrict automated access, so read them before using one.
Does the export include my users?
No. The ZIP and GitHub sync contain code, and CSV exports contain table records. User accounts and their passwords stay with Base44; its documentation says app users can’t be exported. Our guide to exporting Base44 users covers what you can read out and what that means for passwords.
Can I run the exported code without Base44?
Not as it is. The exported app uses the Base44 SDK, which sends every data, sign-in, function and integration request to Base44’s servers. To run it independently you need either a rewrite of those calls or a backend that answers them the same way. Unbase44 does the second: your code and a Base44-compatible server go into your own GitHub.
Is exporting to GitHub the same as migrating off Base44?
No. The repository holds your frontend and the source of your functions. Your records, users and their passwords, secret values, uploaded files, connectors and the scheduler that runs your automations stay on Base44, and the code still calls Base44 through its SDK. Migrating means moving those too and running a backend that answers the same calls. Our guide to migrating from Base44 sets out the order.
How do I export my Base44 database?
From the Data dashboard, one table at a time as CSV, or through Base44’s API when a table is large. Our guide to exporting your Base44 database covers every route and how to keep the links between tables intact.
Does base44 eject copy my data?
No. It creates a new, separate Base44 project with its own app ID and an empty database. Your schemas are copied; your records aren’t.
Sources
Checked on November 10, 2026. Base44 changes quickly; if something here is out of date, tell us.
- Base44 developer tools (ZIP export and plan requirement)
- Project structure
- GitHub integration (sync rules, reconnecting,
base44 devand--remote) - CLI: eject
- Local development (what runs locally and what is forwarded to Base44)
- Managing your app data (export, import, 5,000-item limit)
- Privacy and security (app users can’t be exported)
- Base44 pricing (plans, prices and features, as of October 2026)
- Billing and plans (upgrades, downgrades, cancelling, buying the same plan again)
- Cloud sandbox (Builder plan for access from outside the editor)
- Base44 terms of service (account credentials, restricted use, yearly fees)
- Changing your account settings (two-factor authentication)
- Chrome Web Store help: permission warnings
- Chrome developer docs: how installed extensions are checked for updates