Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →To self-host Parse Server on a VPS, you need a supported Node.js release, Parse Server, and either MongoDB or PostgreSQL. Put Parse behind an HTTPS reverse proxy, keep the database private, protect the master key, and configure permissions before exposing an endpoint to the internet. Docker is optional; a native Node.js installation is equally valid when you can manage the runtime and service process yourself.
Antihost offers Linux VPS plans with full root access, unlimited traffic on a 1 Gbps port and a 14-day free trial.
This guide covers architecture, version selection, installation, database and file-storage choices, HTTPS, firewalling, Parse security settings, health checks, backups, schema changes, and upgrade planning. It does not prescribe a universal VPS size because Parse publishes no CPU or RAM minimum; capacity depends on traffic, database size, file volume, and workload.
As an Amazon Associate I earn from qualifying purchases.
What a production Parse Server VPS needs
A public deployment normally has four layers:
- DNS: a hostname such as
api.example.compointing to the VPS. - HTTPS reverse proxy: the only publicly exposed application entry point, terminating TLS and forwarding requests to Parse Server.
- Parse Server: running on Node.js, preferably bound to loopback or a private network rather than a public interface.
- Database and file storage: MongoDB or PostgreSQL for application data, plus a deliberate file adapter for uploads.
Keep the database reachable only from the VPS or a private network. Expose only the reverse proxy’s HTTPS port to the internet. Parse’s official deployment guidance warns that publishing an unadapted server can cause intrusions, data leaks, and unexpected costs, so a working process is not yet a safe production deployment.
Choosing one VPS versus managed services
You can run Parse and the database on one VPS for maximum control and a simple network layout. Separate managed database or object-storage services reduce patching and backup work and can improve failure isolation, but they add service bills, credentials, firewall rules, and network configuration. Decide according to your recovery objectives and operational capacity rather than assuming that one layout is always best.
#1 Best Overall
How much CPU and RAM?
There is no authoritative universal minimum for Parse Server. Size from expected request rate, concurrent work, database growth, indexes, file volume, and background jobs. Start with monitoring enabled, leave headroom for database maintenance and traffic bursts, and resize from observed CPU, memory, disk-I/O, and latency rather than from a generic VPS recommendation.
Choose compatible versions before installing
Pin the Parse Server major version and then select runtime and database versions from its current compatibility table. Do not copy versions from an old tutorial.
| Parse Server compatibility range | Node.js listed as compatible | MongoDB listed as compatible | PostgreSQL listed as compatible |
|---|---|---|---|
| Through Parse Server 9.x | Node.js 20 | MongoDB 7 | PostgreSQL 16 |
| Through Parse Server 10.x | Node.js 22 | MongoDB 8 | Not stated in the cited compatibility entry |
| Through Parse Server 11.x | Node.js 24 | Not stated in the cited compatibility entry | Not stated in the cited compatibility entry |
These are release-dependent ranges, not a promise that every future patch combination will work. Recheck the project README when changing a major version, Node.js, MongoDB, or PostgreSQL. PostgreSQL deployments that use geographic or location features require PostGIS.
Native Node.js or Docker?
Native installation
Native Node.js is straightforward when you already operate system services, package updates, and log rotation. Install a compatible Node.js version, install the parse-server package, provide configuration through a file or environment variables, and run it under a service manager with a restart policy. Keep the Parse major version pinned in your package-management process so an unattended update cannot change the server underneath you.
Docker installation
Docker gives you an immutable image and a repeatable upgrade path. Persist configuration and any local file storage outside the disposable container, keep secrets out of shell history where possible, and send container logs to durable logging.
The official image accepts the core settings as command-line options. This example binds Parse to loopback so a reverse proxy can be the public entry point:
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
docker run --name my-parse-server
-p 127.0.0.1:1337:1337
-v config-vol:/parse-server/config
-d parse-server
--appId APPLICATION_ID
--masterKey MASTER_KEY
--databaseURI mongodb://user:password@db-host/dbnameReplace every placeholder, use a secret-management method appropriate to the VPS, and restrict access to the database credentials. The databaseURI is required. In production, add a container restart policy or an external service supervisor and verify that logs, backups, and file uploads survive container replacement.
Decision guide
| Choose | Best fit | Main trade-off |
|---|---|---|
| Native Node.js | Operators comfortable with OS packages and service managers | Runtime and dependency drift require disciplined maintenance |
| Docker | Repeatable builds, isolated dependencies, and image-based rollouts | Volumes, secrets, networking, and container logging become additional responsibilities |
Install Parse Server on the VPS
1. Prepare the host
- Choose a supported Linux distribution and apply security updates.
- Create a non-root operating-system account for routine administration.
- Assign a DNS name and point its record to the VPS address.
- Decide whether MongoDB/PostgreSQL and file storage will be local or managed.
- Allow only the administration access you need and plan firewall rules before starting Parse.
2. Install a compatible Node.js release
Install the Node.js major version that matches your pinned Parse Server release. Verify both versions before installing Parse; a newer runtime copied from another guide can fall outside the supported range.
node --version
npm --version3. Install and pin Parse Server
Install the package in the application directory using your chosen package-management policy. Keep the major version explicit and record the lockfile or image digest used for each deployment. Start the process with a configuration file or environment variables rather than placing secrets in source code.
4. Supply the minimum configuration
Every deployment needs these three core values:
appId: the identifier clients use for this Parse application.masterKey: a high-privilege secret that bypasses normal application security.databaseURI: the MongoDB or PostgreSQL connection string.
A practical production configuration also sets serverURL to the public HTTPS address clients will call, commonly ending in /parse. Add a Cloud Code path when the application uses trusted server-side functions, and configure a file adapter when uploads should not use the default arrangement.
Recommended Free Tools
{
"appId": "APPLICATION_ID",
"masterKey": "STORE_THIS_OUTSIDE_SOURCE_CONTROL",
"databaseURI": "mongodb://user:password@private-db/dbname",
"serverURL": "https://api.example.com/parse",
"allowClientClassCreation": false,
"enforcePrivateUsers": true
}The final two settings are hardening choices discussed below: disable client-created classes after the schema is established, and consider private users on Parse Server 5.0.0 and later. Adjust them only after checking your application’s behavior.
5. Run it as a managed service
Use a service manager or container supervisor so Parse starts after reboot, restarts after an unexpected exit, and writes logs to durable storage. Run it as a restricted account, bind it to loopback or a private interface, and do not expose port 1337 directly to the internet. Confirm locally that the process responds before adding the reverse proxy.
MongoDB or PostgreSQL?
MongoDB
Parse documentation describes MongoDB as the preferred choice for many deployments. It is a natural fit when your data model is document-oriented or when you want the commonly used Parse database path. You remain responsible for indexes, upgrades, authentication, network restrictions, and backups unless you use a managed service.
PostgreSQL
PostgreSQL is a good choice when you expect a stable, relationally structured schema or already operate PostgreSQL. PostGIS is required for Parse geographic/location features. You must still manage indexes and confirm that every Parse feature your application needs is supported by the selected adapter and version.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Fix the driver behind crashes, sound loss and screen glitches3Repair Windows errors before they cause bigger problemsRank #3
| Question | MongoDB | PostgreSQL |
|---|---|---|
| Typical reason to choose it | Document-oriented data and common Parse deployment patterns | Stable schema, relational tooling, or an existing PostgreSQL platform |
| Geographic features | Use the supported MongoDB path | PostGIS is required |
| Indexes | Operator-managed | Operator-managed |
| Managed option | Managed MongoDB services can reduce patching and backup work | Availability and features depend on your selected provider |
Managed MongoDB services can simplify maintenance for operators new to MongoDB, but they add a separate bill and require carefully scoped network access. Whichever database you choose, keep it off the public internet and test restoration rather than assuming that a successful backup command proves recoverability.
Put HTTPS and a firewall in front of Parse
Reverse-proxy layout
- Obtain a certificate for the DNS name.
- Configure a maintained reverse proxy to terminate TLS and redirect HTTP to HTTPS.
- Forward the proxy’s Parse route, such as
/parse, to the loopback or private Parse listener. - Preserve the client address through forwarding headers and configure Parse’s trust settings to match the proxy you actually control.
- Test API calls through the public HTTPS URL, not only against localhost.
Incorrect forwarding trust can make audit records and rate limits use the proxy’s address instead of the real client address. Trust only the proxy hops you operate; do not blindly trust arbitrary incoming forwarding headers.
Firewall rules
- Allow HTTPS to the reverse proxy.
- Allow administrative access only from trusted networks or a secured management path.
- Allow database traffic only between the database and the Parse host or private network.
- Deny direct public access to Parse’s internal port, the database port, and administrative interfaces.
Parse’s security guidance recommends firewalling all endpoints, rate limiting public endpoints, and using especially restrictive rules for private endpoints such as Parse Dashboard.
Secure Parse before launch
Protect the master key
Parse describes possession of the master key as equivalent to root access to the application’s servers. Store it outside source control, restrict the file or secret-store permissions, rotate it through a planned process, and never ship it in a client application. Client keys are not secrets because they are delivered to clients; privileged actions belong in trusted Cloud Code, where the server can use the master key without exposing it.
Review CLPs and ACLs
For every class, review Class-Level Permissions (CLPs) for find, get, create, update, delete, and add-field operations. Then review object-level ACLs and ownership rules. Start from deny-by-default for sensitive data and open only the operations the product requires. Test as an unauthenticated user, a normal authenticated user, and an administrator; a rule that works in the Dashboard is not necessarily safe for a client SDK.
Stop clients changing the schema
Set allowClientClassCreation: false after the intended schema is established. This prevents clients from silently creating classes in production. If CI/CD is the sole schema authority, use lockSchemas: true so clients or Dashboard cannot make out-of-band schema changes.
Make user records private where appropriate
Parse Server 5.0.0 and later supports enforcePrivateUsers: true. Consider enabling it when new users should not receive public read access by default, then explicitly grant the access your application needs.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Protect Dashboard and GraphQL tools
Do not expose Parse Dashboard or a GraphQL playground to the public internet without authentication and network restrictions. An exposed playground can allow visitors to read or change application data. Put administrative tools behind a private network, VPN, IP allowlist, or equivalent access control.
Add rate limiting at the right layer
Parse Server 6.0.0 and later supports rateLimit rules for server routes, Cloud Functions, and beforeSave triggers. Rules can specify a request path, methods, time window, count, error message, and optional Redis storage. Application-level limits are useful, but traffic has already consumed server resources by the time it reaches Parse. Enforce broad abuse controls at a cloud or CDN edge when possible, then use Parse limits for application-specific protection. Ensure the proxy’s trusted client-IP configuration is correct before relying on IP-based limits.
Choose file storage deliberately
Parse supports these file adapters:
| Adapter | Where files live | Operational implications |
|---|---|---|
GridFSBucketAdapter |
MongoDB | Keeps files with MongoDB but increases database storage and backup scope |
S3Adapter |
S3-compatible object storage | Independent scaling and durability; requires credentials, bucket policy, and network configuration |
GCSAdapter |
Google Cloud Storage | Independent object storage; requires the provider’s identity and access controls |
FSAdapter |
Local VPS filesystem | Simplest for one VPS, but migration, disk failure, and horizontal scaling require extra work |
Local storage is reasonable for a small single-server deployment only when the filesystem is included in tested backups. Object storage is usually a better fit when files need independent scaling or redundancy. Whichever adapter you select, test uploads, downloads, deletion, permissions, and restoration before launch.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Health checks, logs, and backups
Use the Parse liveness endpoint
Probe GET /parse/health from the reverse proxy or monitoring system. A healthy response is:
{"status":"ok"}Startup states include initialized, starting, ok, and error. Treat this endpoint as a liveness signal, not proof that every dependency or business transaction works.
Add dependency and application checks
- Database connectivity and query latency.
- Disk capacity and inode usage, especially with local files or database data.
- Memory pressure, CPU, restart count, and event-loop health.
- HTTP error rates, authentication failures, and rate-limit events.
- A representative authenticated API transaction executed by monitoring, without exposing user data.
- Backup completion and the age of the last successful restore test.
Back up data and files
Parse does not publish a universal backup schedule. Choose one from your recovery-point and recovery-time objectives. Back up the database, file storage, configuration, and deployment metadata as appropriate; encrypt backups, restrict access, retain more than one recovery point, and periodically restore into an isolated environment. A database backup without separately backed-up local files is not a complete Parse recovery.
Handle schema changes and upgrades safely
Schema deployment checklist
- Take a full database backup before changing classes, fields, indexes, or permissions.
- Apply the change through your controlled deployment path.
- Inspect the resulting classes, fields, indexes, and CLPs.
- Run representative reads and writes with each relevant role.
- Confirm health and monitoring before declaring the change complete.
Use lockSchemas: true when CI/CD must be the only schema authority. Do not let a client or an ad-hoc Dashboard edit create an undocumented production state.
Best Value
Parse Server upgrade checklist
- Pin the target Parse Server major version.
- Read that release’s compatibility table for Node.js and database versions.
- Stage the upgrade against a recent backup and representative data.
- Verify
/parse/health, authentication, queries, file operations, Cloud Code, and scheduled jobs. - Deploy with a rollback plan and monitor errors, latency, memory, and database load.
There is no universal zero-downtime recipe that fits every VPS, database, adapter, and schema. Rollout order and required capacity are deployment-specific; test the sequence your architecture can actually support.
PC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteCommon failure modes and fixes
The process starts but clients cannot connect
- Check that
serverURLmatches the public HTTPS URL, including the/parsepath when used. - Confirm DNS points to the VPS and the certificate covers the hostname.
- Verify the reverse proxy forwards to the actual listener and that the firewall permits HTTPS.
- Ensure Parse is bound to the interface the proxy can reach.
Database connection errors
- Validate the complete
databaseURI, credentials, and database name. - Check that the database accepts connections from the Parse host but not from the public internet.
- Confirm the database version is compatible with the pinned Parse release.
- Inspect firewall, private-network, TLS, and managed-service allowlist settings.
Users can read or change data they should not
- Re-audit CLPs and object ACLs for every affected class.
- Check whether the master key was exposed in a client bundle or log.
- Move privileged operations into Cloud Code.
- Enable private-user behavior where appropriate and retest as each role.
Uploads disappear after a restart
This commonly indicates local files were stored inside an ephemeral container or on an unbacked-up disk. Use a persistent volume, include the filesystem in backups, or move uploads to an object-storage adapter with a tested retention policy.
Rate limits affect all users or fail to stop abuse
Check trusted proxy headers and the identity used for counting. Remember that Parse-level limits occur after traffic reaches the application; add edge controls for volumetric abuse and keep application rules for endpoint-specific protection.
A launch checklist
- Supported Node.js, Parse Server, and database versions are pinned.
appId,masterKey, anddatabaseURIare present; the master key is secret.serverURL, Cloud Code, and file-adapter settings match the production design.- Parse listens on loopback or a private network; only HTTPS is public.
- TLS renewal, HTTP-to-HTTPS redirection, forwarding headers, and firewall rules work.
- Database access is private and indexes are reviewed.
- CLPs, ACLs, user privacy, schema controls, Dashboard, and GraphQL access are tested.
- Rate limiting exists at the edge and, where useful, in Parse Server.
- Logs, restart behavior, disk and memory alerts, and
/parse/healthmonitoring are active. - Database and file backups have been restored successfully in a test environment.
- A rollback plan exists for schema and Parse Server upgrades.
Frequently Asked Questions
Can Parse Server run without Docker?
Yes. Install a compatible Node.js release, install and pin the Parse Server package, provide the required configuration, and run it under a service manager. Docker is an optional packaging and deployment method.
Is PostgreSQL supported instead of MongoDB?
Yes. Parse supports PostgreSQL; choose it when its schema and operational model fit your application. PostGIS is required for geographic/location features, and you must manage indexes and backups.
Free tools Windows power users keep installed
One-click scans. No signup required.
What should be publicly reachable on a Parse VPS?
Normally only the HTTPS reverse proxy. Keep Parse’s internal listener, the database, Dashboard, and administrative tools private or restricted to trusted networks.
What does a healthy Parse health check return?
A healthy GET /parse/health request returns {"status":"ok"}. Add separate checks for database connectivity, storage, backups, and representative application transactions.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
