How to export your Base44 database: every table and record
Base44 has no database download and no connection string. Your records come out through the dashboard, one table at a time, or through its API. Here is each route, what it misses, and how to keep the links between tables working.
Updated 10 min readBy the Unbase44 team
On this page
- 01The short version
- 02What a Base44 database holds
- 03Route 1: CSV from the Data dashboard
- 04Route 2: the Apps API with a personal access token
- 05Route 3: base44 exec and --privileged
- 06Why base44 eject gives you an empty database
- 07What a database export leaves out
- 08Backups on Base44
- 09Putting the data somewhere else
- 10Moving the database together with the app
- 11A checklist for exporting your Base44 database
- 12Questions and answers
- 13Sources
The short version
Base44 doesn’t offer a database download or a connection string. Everything goes through its dashboard and its API, so exporting a Base44 database comes down to three routes:
- CSV from the Data dashboard, one table at a time. It works on every plan, Free included, and needs no code.
- A script against the Apps API, with a personal access token, for large tables or regular backups. A single request returns at most 5,000 records, so the script has to page through.
base44 exec, the CLI’s way to run a one-off script with the SDK as yourself.
Some things don’t come with any of them. Your app’s users and their passwords, your secrets’ values and your uploaded files are separate problems, each covered below. And base44 eject, which sounds like an export, copies your table definitions into a new Base44 project with an empty database: the schemas come across, the data doesn’t.
What a Base44 database holds
Base44 describes its database as a NoSQL store that is MongoDB-compatible. Each table (Base44 calls them entities) is a collection of documents (Entities overview). Before you export, it helps to know what that means for the files you’ll get:
- Records are documents. A record can hold nested objects and lists, and the schema can change at any time without a migration. When you check an export, look closely at fields that hold lists or nested objects.
- Every record carries built-in fields alongside yours: its ID, its creation and update dates, and
created_by, which holds the creator’s email address. - Relationships are IDs. When an order belongs to a customer, the order stores the customer’s ID in a field. Nothing in the database enforces that the customer exists, and nothing in an export will either.
- Users have their own table. Every app has a built-in
Usertable with an ID, email, name, role, collaborator role, dates and any custom fields you added (User schema). It lives in the Users section, not with your other tables. - Files are links. Uploads sit in Base44’s file storage. Your records hold links to them, not the files themselves.
For the full picture of how the database fits with sign-in, functions and security rules, see Base44’s backend and database explained.
Route 1: CSV from the Data dashboard
This is the documented export, and it needs no code (Managing your app data).
- Open your app’s dashboard and go to Data.
- Select a table.
- Click More actions, then Export. You get that table as a CSV file.
- Repeat for every table. An app with twenty tables means twenty exports.
Three details decide whether the copy is complete:
- 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. Don’t judge a large table by what the screen shows.
- Keep the ID column. Other tables point at records by ID. If the IDs get lost or rewritten on the way to a new system, every link between your tables breaks.
- Users aren’t in it. The CSV export covers Data tables. Base44’s privacy documentation says app users can’t be exported. Our guide to exporting Base44 users covers the ways to read the user records out.
Name each file after its table and the date, and keep the set together. A folder of exports from different days is hard to trust when you need it.
Route 2: the Apps API with a personal access token
A script is the better route when tables are large, when you want the export on a schedule, or when you want JSON instead of CSV. Base44’s dashboard has an API page with ready-made snippets for the JavaScript SDK, plain JavaScript fetch, cURL and Python, which is a good place to start.
Three rules shape the script:
- Access rules apply to the token’s user. The Apps API answers as the person whose personal access token it uses. Reads that the rules deny don’t raise an error: a list comes back empty. Use the token of someone the rules let read every table, and check that no table comes back short.
- 5,000 records per request, with no warning. Since 27 November 2025, a single request returns at most 5,000 items, and Base44’s Apps API documentation says the response doesn’t tell you when it was cut short. A script that asks for a whole table in one call stops at 5,000 without an error. Ask for the records in pages, keep going until a page comes back with fewer records than you asked for, and compare the total with a record count.
- Rate limits are per workspace. The management API counts requests per workspace, not per person, with a base allowance for Free and Starter that is multiplied by 2 on Builder, 3 on Pro, 5 on Elite and 10 on Enterprise. Listing and counting records share a base allowance of 70 requests a minute per app (Rate limits). Pace the script so it stays inside the limit.
Save the output as JSON if you can. JSON keeps nested objects and lists as they are, and Base44’s own import accepts CSV, Excel and JSON.
For the user list, the Apps API has a separate List app users endpoint, marked beta as of October 2026. It returns user records, never passwords.
Route 3: base44 exec and --privileged
The Base44 CLI (npm install -g base44@latest) includes base44 exec, which runs a one-off script with the SDK. It runs as you, so the same rules apply as in your app: the 5,000-item limit per request, and the access rules on each table.
That second point catches people out. If a table’s rules hide records from you, the script gets fewer records and no error. The --privileged option bypasses row-level rules, and it’s available to the app’s owners and editors. If your tables also use field-level rules, check that every field you expect is in the output.
base44 exec suits a developer who already uses the CLI. If you don’t, Route 1 or a short API script is simpler.
Why base44 eject gives you an empty database
base44 eject is the command people find when they search for a way out. According to its reference page, it copies an existing app into a separate local project: the frontend code, the entity schemas and other backend resources. It then creates a new backend project with its own app ID, and that project starts with an empty database. Schemas are copied; records aren’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. To fill it, you export the records with one of the routes above and import them, and Base44’s import only adds rows. Check afterwards that the links between tables still point at the right records. Our guide to exporting your Base44 code covers eject alongside the ZIP download and GitHub sync.
What a database export leaves out
The database is one part of your app’s backend. This is where each part ends up when you export your tables:
| Part of the app | In a CSV or API export? | Where it stays |
|---|---|---|
| Table records | Yes | Your files |
| Relationships between tables | As IDs stored in fields | Your files, if you keep the IDs |
| Access rules | No; an export holds records | Stored with each table on Base44 |
| Users | No; user records can be read through the API | Base44’s Users section |
| Passwords | No | Base44’s sign-in service |
| Uploaded files | Links only | Base44’s file storage |
| Secret values | No; names are visible, values are write-only | Base44’s secrets store |
| Backend functions | No; source files come with the code ZIP or GitHub sync, on Builder or higher | Base44’s function runtime |
| Automations and workflows | No | Base44’s scheduler and event system |
Backups on Base44
Base44 keeps deleted records for 30 days in Recently deleted, where you can restore them, on every plan. After that they are permanently removed.
Automatic backups, where you can review, download and restore earlier states of your tables, are an Elite and Enterprise feature: kept for 7 days on Elite and 30 days on Enterprise (Backup & Restore). They cover table records only, not uploaded files or your app’s users.
On other plans, your backup is whatever you export yourself. In practice that means CSV exports on a regular schedule, or a paginated API script you run on a timer.
Putting the data somewhere else
Where the export goes next decides how much work it is.
- Back into Base44. CSV, Excel and JSON imports add new rows only and never update existing records. Importing into a table that already holds the same records won’t merge them.
- Into MongoDB. The records are already documents, so they keep their shape. Keep each record’s ID as it was, so the links between tables still resolve.
- Into Postgres or Supabase. A relational database wants fixed columns. Nested objects and lists have to be reshaped into columns or separate tables, and the IDs that link tables become foreign keys. That’s before the access rules and the code that queries the data are rewritten. Our guide to moving a Base44 app to Supabase lays out the rest.
Whichever way you go, your users don’t come with the data, and their passwords never leave Base44. The usual answer is a password reset for everyone.
Moving the database together with the app
If the reason you want your data out is to run the app somewhere you control, you can move the database and the app together instead of exporting and rebuilding. That’s what Unbase44 does. It is made by Codama and is independent of Base44 and Wix.
- Tables and records. All tables move with their access rules, and all records move with their IDs intact into your own MongoDB, on your Railway account or a Linux server you reach over SSH.
- Files. Uploaded files move to your own storage, including private files.
- Users. Every user moves, and they keep their passwords: each user’s first sign-in on the new app is checked against Base44 once, then your app stores its own hash. Keep the Base44 app published until your active users have signed in once.
- The app around the data. Your app’s code and a Base44-compatible backend go into your own private GitHub repository, so the app keeps reading and writing the data the way it does today.
The copy starts in test mode. Your Base44 app keeps serving users, and the copy holds anything it would send out instead of sending it, so you can check the data before you switch. Our guide to migrating from Base44 sets out the full order of a move. The analysis is free and shows your tables, record counts, users and files, with a one-time price, before you connect any account or pay. Run the free analysis.
A checklist for exporting your Base44 database
- Export every table to CSV, small ones included, and keep the ID column.
- For tables over 5,000 records, check that the export holds them all, or use a paginated script and compare its total with a record count.
- Export your user records separately; the Data export doesn’t include them.
- Note which fields hold file links, and decide where those files will live.
- Write down your secrets’ names (the values can’t be exported).
- Note each table’s access rules: who can read and change what.
- Keep each set of exports together, named by table and date.
- On a plan without automatic backups, repeat the export on a schedule.
Questions and answers
How do I export my Base44 database?
Open Data in your app’s dashboard, select a table, click More actions, then Export, and repeat for every table. That gives you one CSV per table, on any plan. For large tables or regular backups, a script against the Apps API does the same with pagination. Users, passwords, secret values and uploaded files aren’t part of either export.
Can I export more than 5,000 records from Base44?
Yes. The dashboard’s table view shows up to 5,000 items, but the CSV export includes the whole table. Through the API or the SDK, a single request returns at most 5,000 items without saying it was cut short, so a script has to page through the records and check the total.
Can I connect to my Base44 database directly?
Not in any way Base44 documents. There’s no connection string and no documented way to connect a database client, a BI tool or a backup job to the database. Access goes through the dashboard, CSV export and import, the Apps API, the SDK and the CLI.
Does Base44 back up my data?
Deleted records can be restored from Recently deleted for 30 days on every plan. Automatic backups of table records are included on Elite (7 days) and Enterprise (30 days); they don’t cover uploaded files or users. On other plans, keep your own exports.
Does base44 eject copy my data?
No. It copies your code and table schemas into a new, separate Base44 project with its own app ID, and that project starts with an empty database. Your records stay in the original app.
Does a database export include my users?
No. The CSV export covers Data tables, and Base44’s privacy documentation says app users can’t be exported. You can read user records out through the Apps API, a backend function or an owner-only page, but passwords never leave Base44. Our guide to exporting Base44 users explains what that means if you move.
Sources
Checked on November 10, 2026. Base44 changes quickly; if something here is out of date, tell us.
- Managing your app data (CSV export, 5,000-item table view, imports, deleted records, API snippets)
- Entities overview (MongoDB-compatible document database)
- Entity security (row- and field-level rules)
- User schema (built-in user fields)
- Apps API: entities (5,000 items per request, no truncation signal)
- Apps API: rate limits (per workspace, plan multipliers, 70 requests a minute)
- Apps API: List app users (beta)
- CLI: eject (new project, empty database)
- Backup & Restore (Elite and Enterprise)
- Privacy and security (app users can’t be exported)
- Base44 developer tools (ZIP export and plan requirement)