Each security feature in NeoSQL protects something different against someone different. Choosing by name alone leads to mistakes such as "it is encrypted, so teammates cannot see the data". This page sets out what each feature protects, against whom, and where its limits are, and ends with what leaves your device even when you use NeoSQL without signing in.
At a glance
| Feature | Protects | Against | Where | Does not prevent |
|---|---|---|---|---|
| Standard encryption | Connection details | A leak of the NeoSQL server's database | Account projects. Always on | An operator who holds both the server code and key management (AWS KMS) permissions |
| Zero-knowledge encryption (Secret Key Lock) | Connection details | Anyone without the secret key, including NeoSQL operators | Account projects. The owner turns it on | A lost secret key cannot be recovered by anyone |
| OS secure storage | Connection secrets, AI keys stored on this device | Reading this device's settings file as it is | Local projects (desktop) | In environments without OS secure storage, values are stored in plain text |
| Sensitive data masking | Sensitive column values being shown on screen | Teammates in masked roles | Account projects. Turned on per role | Stored data is not encrypted. It does not prevent bypass queries through views or functions. |
Connection details here means the host, port, JDBC URL, database name, database user and password, SSL certificate, key and key password, and the SSH and proxy accounts. Connection names, the DBMS type and schema lists are not encrypted. None of these features encrypts the data inside your database.
Standard encryption in account projects
- When you save a connection in an account project, its details are stored encrypted on the NeoSQL server. Each project gets its own data key, which encrypts the details with AES-256-GCM; the data key itself is wrapped again by an AWS KMS master key (envelope encryption). Even if the server's database leaked in full, nothing could be decrypted without the KMS key.
- There is nothing to turn on. The data key is created when the first connection of the project is saved.
- When a connection is used, the server that runs your queries receives the decrypted details from the NeoSQL server and connects to the database. On the desktop that is the local server on this device; on the web it is the NeoSQL server.
- Limit: someone has to decrypt the details to connect to the database, so an operator who holds both the server code and KMS permissions could decrypt them in theory. To rule that out as well, turn on zero-knowledge encryption.
Zero-knowledge encryption
- The owner of an account project turns it on with the Secret Key Lock button in the explorer toolbar on the left of the project screen. For anyone else the button is disabled, and local projects do not have it.
- Once on, the data key is wrapped not by KMS but by a key derived (with Argon2id) from a secret key only you know. The secret key is never sent to or stored on the NeoSQL server.
- You enter the secret key to unlock the project when you open it. The unlocked data key lives only in the memory of that device (the browser tab or the desktop app), is sent to the server with each request, and is used only while that request is processed. The server does not keep the data key.
- That is why each device unlocks separately. On the desktop, the Save to this computer option stores the secret key in the OS keychain so it unlocks automatically next time; browsers cannot do this. The idle time after which the project locks itself is set in the screen.
- Limit: the guarantee covers the time the project is locked. While you work unlocked, the server decrypts the details at the moment it processes each request. Details saved before you turned it on were protected only by standard encryption until then, so for very sensitive credentials the app recommends changing the password on the database side afterwards.
- NeoSQL does not pass the secret key to teammates, so share it with them yourself. When you change the secret key, old keys that teammates saved in their keychains no longer work, so share the new key again.
OS secure storage in local projects
- Local projects are desktop-only and stored only on this device. Their connection details are not sent to the NeoSQL server either, so standard and zero-knowledge encryption do not apply.
- Secret values (the database user and password, JDBC URL, SSL certificate and key, and SSH and proxy accounts) are kept apart from the project data and encrypted with a key managed by the OS secure storage (macOS Keychain, Windows DPAPI and so on). The project data keeps only a pointer to them. Settings that are not secret, such as the host and port, stay in the project data.
- In environments where the OS secure storage is unavailable, these values are stored in plain text on this device. If you enter a secret such as a password and save the connection, the Credentials will not be encrypted confirmation appears first.
- AI keys stored on this device are kept in the same storage in the same way.
Masking is not encryption
- In an account project, turning on Sensitive Data Masking for a role in the tab shows that role's members masked values for columns marked as sensitive. The owner and roles with full permissions always see the original values.
- Values are masked by the server that runs the query, before the results are sent to the screen. On the desktop this happens on that member's device; on the web, on the NeoSQL server.
- Masking only controls what is shown on screen, and the app shows the following warning under this setting.
- Values sent to AI Assistant or an external MCP client are masked regardless of role when Always mask sensitive data is turned on in the connection's AI settings. See AI and MCP.
Where AI keys are stored
| Key | Stored in | Protection | Available in |
|---|---|---|---|
| Account key | The NeoSQL server (your account) | The same KMS envelope encryption as standard encryption. Not covered by zero-knowledge encryption | Web, desktop when signed in |
| Device key | This device | OS secure storage. Screen-side code cannot read the key; only the local server that calls the AI retrieves it | Desktop, with or without signing in |
Which key is used when is explained in AI and MCP.
What leaves your device without signing in
The desktop app without signing in does not send the NeoSQL server any request that needs an account. It sends only the requests below, and failures never block your work (only a bug report you send yourself tells you when it fails). Requests to the NeoSQL server carry this device's identifier (device ID), whether it is the desktop or the web, and the app version.
| Request | When | What is sent |
|---|---|---|
| Usage statistics | When you move between screens | The screen name and address (including the project ID on project screens) and the original referrer |
| App version check | When a production desktop build starts and when it checks for updates | The installed version, a launch flag and the number of projects |
| Release notes | After an update | The app version and display language |
| Notices | While the app is running | The notice channel connection and notice list requests. Only notices sent to everyone are received |
| Public assets | When you browse or download official packs or public template packs and data dictionaries | The asset you ask for |
| AI model list | When you add or edit an AI key | The AI provider you chose |
| Bug report | When you send one yourself from the Report a Bug dialog | The title and description you wrote, attached screenshots, and the error log and the Environment information you can review before sending |
- Turn off usage statistics with the Send usage statistics option in the screen. When off, screen navigation is not sent, and other requests carry a do-not-record flag so the server keeps no statistics. The device ID is still sent because features rely on it.
- With usage statistics the server records the request's IP address and app information (User-Agent). While you are signed in, usage statistics are recorded together with your account.
- Some traffic goes elsewhere than the NeoSQL server. The desktop connects from this device straight to the databases in your connections, and update files are downloaded from GitHub. When you use AI, your questions and the selected database information go to the AI provider you chose (AI and MCP).
- The web app is always signed in, and database connections and AI requests are made by the NeoSQL server. The differences are explained in Web and desktop.
Things to keep in mind
- Encryption protects the connection details NeoSQL stores, not the data inside your database. To truly keep values from teammates, encrypt those columns on the database side or split database account permissions.
- NeoSQL does not keep the zero-knowledge secret key. Decide how you will store the secret key safely before turning it on.
- On a device where the confirmation about unavailable OS secure storage appears, secrets stay in plain text. On a shared device, do not store passwords in local projects.
Related pages
- Zero-knowledge encryption: the screens for turning the secret-key lock on, unlocking and changing it.
- Column masking: how to set masking by role, sensitive column and pattern.
- Sign-in and project types: the difference between local and account projects.
- Web and desktop: where the web app and the desktop app connect to databases from.
- AI and MCP: the data AI receives and the connection policies.