Github url


by parse-community

parse-community /parse-server

API server module for Node/Express

17.6K Stars 4.3K Forks Last release: 3 months ago (4.2.0) Other 3.2K Commits 104 Releases

Available items

No Items, yet!

The developer of this repository has not created any items for sale yet. Need a bug fixed? Help with integration? A different license? Create a request here:

Parse Server

Parse Server is an open source backend that can be deployed to any infrastructure that can run Node.js.

Follow on TwitterBuild statusCoverage statusnpm versionJoin the conversationGreenkeeper badge

MongoDB 3.6 MongoDB 4.0

Our Sponsors

Our backers and sponsors help to ensure the quality and timely development of the Parse Platform.

🥉 Bronze Sponsors

Backers on Open CollectiveSponsors on Open Collective

Parse Server works with the Express web application framework. It can be added to existing web applications, or run by itself.

The full documentation for Parse Server is available in the wiki. The Parse Server guide is a good place to get started. An API reference and Cloud Code guide are also available. If you're interested in developing for Parse Server, the Development guide will help you get set up.

Getting Started

The fastest and easiest way to get started is to run MongoDB and Parse Server locally.

Running Parse Server

Before you start make sure you have installed:


$ npm install -g parse-server mongodb-runner $ mongodb-runner start $ parse-server --appId APPLICATION\_ID --masterKey MASTER\_KEY --databaseURI mongodb://localhost/test

Note: If installation with


fails due to permission problems (

npm ERR! code 'EACCES'

), please refer to this link.

Inside a Docker container

$ git clone $ cd parse-server $ docker build --tag parse-server . $ docker run --name my-mongo -d mongo $ docker run --name my-parse-server -v cloud-code-vol:/parse-server/cloud -v config-vol:/parse-server/config -p 1337:1337 --link my-mongo:mongo -d parse-server --appId APPLICATION\_ID --masterKey MASTER\_KEY --databaseURI mongodb://mongo/test

You can use any arbitrary string as your application id and master key. These will be used by your clients to authenticate with the Parse Server.

That's it! You are now running a standalone version of Parse Server on your machine.

Using a remote MongoDB? Pass the


parameter when starting


. Learn more about configuring Parse Server here. For a full list of available options, run

parse-server --help


Saving your first object

Now that you're running Parse Server, it is time to save your first object. We'll use the REST API, but you can easily do the same using any of the Parse SDKs. Run the following:

$ curl -X POST \ -H "X-Parse-Application-Id: APPLICATION\_ID" \ -H "Content-Type: application/json" \ -d '{"score":1337,"playerName":"Sean Plott","cheatMode":false}' \ http://localhost:1337/parse/classes/GameScore

You should get a response similar to this:

{ "objectId": "2ntvSpRGIK", "createdAt": "2016-03-11T23:51:48.050Z" }

You can now retrieve this object directly (make sure to replace


with the actual


you received when the object was created):

$ curl -X GET \ -H "X-Parse-Application-Id: APPLICATION\_ID" \ http://localhost:1337/parse/classes/GameScore/2ntvSpRGIK
// Response { "objectId": "2ntvSpRGIK", "score": 1337, "playerName": "Sean Plott", "cheatMode": false, "updatedAt": "2016-03-11T23:51:48.050Z", "createdAt": "2016-03-11T23:51:48.050Z" }

Keeping tracks of individual object ids is not ideal, however. In most cases you will want to run a query over the collection, like so:

$ curl -X GET \ -H "X-Parse-Application-Id: APPLICATION\_ID" \ http://localhost:1337/parse/classes/GameScore
// The response will provide all the matching objects within the `results` array: { "results": [{ "objectId": "2ntvSpRGIK", "score": 1337, "playerName": "Sean Plott", "cheatMode": false, "updatedAt": "2016-03-11T23:51:48.050Z", "createdAt": "2016-03-11T23:51:48.050Z" }] }

To learn more about using saving and querying objects on Parse Server, check out the Parse documentation.

Connect your app to Parse Server

Parse provides SDKs for all the major platforms. Refer to the Parse Server guide to learn how to connect your app to Parse Server.

Running Parse Server elsewhere

Once you have a better understanding of how the project works, please refer to the Parse Server wiki for in-depth guides to deploy Parse Server to major infrastructure providers. Read on to learn more about additional ways of running Parse Server.

Parse Server Sample Application

We have provided a basic Node.js application that uses the Parse Server module on Express and can be easily deployed to various infrastructure providers:

Parse Server + Express

You can also create an instance of Parse Server, and mount it on a new or existing Express website:

var express = require('express'); var ParseServer = require('parse-server').ParseServer; var app = express(); var api = new ParseServer({ databaseURI: 'mongodb://localhost:27017/dev', // Connection string for your MongoDB database cloud: '/home/myApp/cloud/main.js', // Absolute path to your Cloud Code appId: 'myAppId', masterKey: 'myMasterKey', // Keep this key secret! fileKey: 'optionalFileKey', serverURL: 'http://localhost:1337/parse' // Don't forget to change to https if needed }); // Serve the Parse API on the /parse URL prefix app.use('/parse', api); app.listen(1337, function() { console.log('parse-server-example running on port 1337.'); });

For a full list of available options, run

parse-server --help

or take a look at Parse Server Configurations.


Parse Server can be configured using the following options. You may pass these as parameters when running a standalone


, or by loading a configuration file in JSON format using

parse-server path/to/configuration.json

. If you're using Parse Server on Express, you may also pass these to the


object as options.

For the full list of available options, run

parse-server --help

or take a look at Parse Server Configurations.

Basic options

  • appId
    (required) - The application id to host with this server instance. You can use any arbitrary string. For migrated apps, this should match your hosted Parse app.
  • masterKey
    (required) - The master key to use for overriding ACL security. You can use any arbitrary string. Keep it secret! For migrated apps, this should match your hosted Parse app.
  • databaseURI
    (required) - The connection string for your database, i.e.
    mongodb://user:[email protected]/dbname
    . Be sure to URL encode your password if your password has special characters.
  • port
    • The default port is 1337, specify this parameter to use a different port.
  • serverURL
    • URL to your Parse Server (don't forget to specify http:// or https://). This URL will be used when making requests to Parse Server from Cloud Code.
  • cloud
    • The absolute path to your cloud code
  • push

Client key options

The client keys used with Parse are no longer necessary with Parse Server. If you wish to still require them, perhaps to be able to refuse access to older clients, you can set the keys at initialization time. Setting any of these keys will require all requests to provide one of the configured keys.

  • clientKey
  • javascriptKey
  • restAPIKey
  • dotNetKey

Email verification and password reset

Verifying user email addresses and enabling password reset via email requires an email adapter. As part of the


package we provide an adapter for sending email through Mailgun. To use it, sign up for Mailgun, and add this to your initialization code:

var server = ParseServer({ ...otherOptions, // Enable email verification verifyUserEmails: true, // if `verifyUserEmails` is `true` and // if `emailVerifyTokenValidityDuration` is `undefined` then // email verify token never expires // else // email verify token expires after `emailVerifyTokenValidityDuration` // // `emailVerifyTokenValidityDuration` defaults to `undefined` // // email verify token below expires in 2 hours (= 2 \* 60 \* 60 == 7200 seconds) emailVerifyTokenValidityDuration: 2 \* 60 \* 60, // in seconds (2 hours = 7200 seconds) // set preventLoginWithUnverifiedEmail to false to allow user to login without verifying their email // set preventLoginWithUnverifiedEmail to true to prevent user from login if their email is not verified preventLoginWithUnverifiedEmail: false, // defaults to false // The public URL of your app. // This will appear in the link that is used to verify email addresses and reset passwords. // Set the mount path as it is in serverURL publicServerURL: '', // Your apps name. This will appear in the subject and body of the emails that are sent. appName: 'Parse App', // The email adapter emailAdapter: { module: '@parse/simple-mailgun-adapter', options: { // The address that your emails come from fromAddress: '[email protected]', // Your domain from domain: '', // Your API key from apiKey: 'key-mykey', } }, // account lockout policy setting (OPTIONAL) - defaults to undefined // if the account lockout policy is set and there are more than `threshold` number of failed login attempts then the `login` api call returns error code `Parse.Error.OBJECT_NOT_FOUND` with error message `Your account is locked due to multiple failed login attempts. Please try again after <duration> minute(s)`. After `duration` minutes of no login attempts, the application will allow the user to try login again.
  accountLockout: {
    duration: 5, // duration policy setting determines the number of minutes that a locked-out account remains locked out before automatically becoming unlocked. Set it to a value greater than 0 and less than 100000.
    threshold: 3, // threshold policy setting determines the number of failed sign-in attempts that will cause a user account to be locked. Set it to an integer value greater than 0 and less than 1000.
  // optional settings to enforce password policies
  passwordPolicy: {
    // Two optional settings to enforce strong passwords. Either one or both can be specified.
    // If both are specified, both checks must pass to accept the password
    // 1. a RegExp object or a regex string representing the pattern to enforce
    validatorPattern: /^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.{8,})/, // enforce password with at least 8 char with at least 1 lower case, 1 upper case and 1 digit
    // 2. a callback function to be invoked to validate the password
    validatorCallback: (password) =&gt; { return validatePassword(password) },
    validationError: 'Password must contain at least 1 digit.' // optional error message to be sent instead of the default "Password does not meet the Password Policy requirements." message.
    doNotAllowUsername: true, // optional setting to disallow username in passwords
    maxPasswordAge: 90, // optional setting in days for password expiry. Login fails if user does not reset the password within this period after signup/last reset.
    maxPasswordHistory: 5, // optional setting to prevent reuse of previous n passwords. Maximum value that can be specified is 20. Not specifying it or specifying 0 will not enforce history.
    //optional setting to set a validity duration for password reset links (in seconds)
    resetTokenValidityDuration: 24*60*60, // expire after 24 hours

You can also use other email adapters contributed by the community such as: - parse-smtp-template (Multi Language and Multi Template)- parse-server-postmark-adapter- parse-server-sendgrid-adapter- parse-server-mandrill-adapter- parse-server-simple-ses-adapter- parse-server-mailgun-adapter-template- parse-server-sendinblue-adapter- parse-server-mailjet-adapter- simple-parse-smtp-adapter- parse-server-generic-email-adapter

Custom Pages

It’s possible to change the default pages of the app and redirect the user to another path or domain.

var server = ParseServer({ ...otherOptions, customPages: { passwordResetSuccess: "", verifyEmailSuccess: "", parseFrameURL: "", linkSendSuccess: "", linkSendFail: "", invalidLink: "", invalidVerificationLink: "", choosePassword: "" } })

Using environment variables to configure Parse Server

You may configure the Parse Server using environment variables:


The default port is 1337, to use a different port set the PORT environment variable:

$ PORT=8080 parse-server --appId APPLICATION\_ID --masterKey MASTER\_KEY

For the full list of configurable environment variables, run

parse-server --help

or take a look at Parse Server Configuration.

Available Adapters

All official adapters are distributed as scoped pacakges on npm (@parse).

Some well maintained adapters are also available on the Parse Server Modules organization.

You can also find more adapters maintained by the community by searching on npm.

Configuring File Adapters

Parse Server allows developers to choose from several options when hosting files:

  • GridFSBucketAdapter
    , which is backed by MongoDB;
  • S3Adapter
    , which is backed by Amazon S3; or
  • GCSAdapter
    , which is backed by Google Cloud Storage

is used by default and requires no setup, but if you're interested in using S3 or Google Cloud Storage, additional configuration information is available in the Parse Server guide.


Parse Server will, by default, log: * to the console * daily rotating files as new line delimited JSON

Logs are also viewable in Parse Dashboard.

Want to log each request and response? Set the


environment variable when starting


. Usage :-

VERBOSE='1' parse-server --appId APPLICATION\_ID --masterKey MASTER\_KEY

Want logs to be in placed in a different folder? Pass the


environment variable when starting


. Usage :-

PARSE\_SERVER\_LOGS\_FOLDER='<path-to-logs-folder>' parse-server --appId APPLICATION_ID --masterKey MASTER_KEY</path-to-logs-folder>

Want to log specific levels? Pass the


parameter when starting


. Usage :-

parse-server --appId APPLICATION\_ID --masterKey MASTER\_KEY --logLevel LOG\_LEVEL

Want new line delimited JSON error logs (for consumption by CloudWatch, Google Cloud Logging, etc)? Pass the


environment variable when starting


. Usage :-

JSON\_LOGS='1' parse-server --appId APPLICATION\_ID --masterKey MASTER\_KEY

Live Queries

Live queries are meant to be used in real-time reactive applications, where just using the traditional query paradigm could cause several problems, like increased response time and high network and server usage. Live queries should be used in cases where you need to continuously update a page with fresh data coming from the database, which often happens in (but is not limited to) online games, messaging clients and shared to-do lists.

Take a look at Live Query Guide, Live Query Server Setup Guide and Live Query Protocol Specification. You can setup a standalone server or multiple instances for scalability (recommended).


GraphQL, developed by Facebook, is an open-source data query and manipulation language for APIs. In addition to the traditional REST API, Parse Server automatically generates a GraphQL API based on your current application schema. Parse Server also allows you to define your custom GraphQL queries and mutations, whose resolvers can be bound to your cloud code functions.


Using the CLI

The easiest way to run the Parse GraphQL API is through the CLI:

$ npm install -g parse-server mongodb-runner $ mongodb-runner start $ parse-server --appId APPLICATION\_ID --masterKey MASTER\_KEY --databaseURI mongodb://localhost/test --publicServerURL http://localhost:1337/parse --mountGraphQL --mountPlayground

After starting the server, you can visit http://localhost:1337/playground in your browser to start playing with your GraphQL API.

Note: Do NOT use --mountPlayground option in production. Parse Dashboard has a built-in GraphQL Playground and it is the recommended option for production apps.

Using Docker

You can also run the Parse GraphQL API inside a Docker container:

$ git clone $ cd parse-server $ docker build --tag parse-server . $ docker run --name my-mongo -d mongo $ docker run --name my-parse-server --link my-mongo:mongo -v cloud-code-vol:/parse-server/cloud -v config-vol:/parse-server/config -p 1337:1337 -d parse-server --appId APPLICATION\_ID --masterKey MASTER\_KEY --databaseURI mongodb://mongo/test --publicServerURL http://localhost:1337/parse --mountGraphQL --mountPlayground

After starting the server, you can visit http://localhost:1337/playground in your browser to start playing with your GraphQL API.

Note: Do NOT use --mountPlayground option in production. Parse Dashboard has a built-in GraphQL Playground and it is the recommended option for production apps.

Using Express.js

You can also mount the GraphQL API in an Express.js application together with the REST API or solo. You first need to create a new project and install the required dependencies:

$ mkdir my-app $ cd my-app $ npm install parse-server express --save

Then, create an


file with the following content:

const express = require('express'); const { default: ParseServer, ParseGraphQLServer } = require('parse-server'); const app = express(); const parseServer = new ParseServer({ databaseURI: 'mongodb://localhost:27017/test', appId: 'APPLICATION\_ID', masterKey: 'MASTER\_KEY', serverURL: 'http://localhost:1337/parse', publicServerURL: 'http://localhost:1337/parse' }); const parseGraphQLServer = new ParseGraphQLServer( parseServer, { graphQLPath: '/graphql', playgroundPath: '/playground' } ); app.use('/parse',; // (Optional) Mounts the REST API parseGraphQLServer.applyGraphQL(app); // Mounts the GraphQL API parseGraphQLServer.applyPlayground(app); // (Optional) Mounts the GraphQL Playground - do NOT use in Production app.listen(1337, function() { console.log('REST API running on http://localhost:1337/parse'); console.log('GraphQL API running on http://localhost:1337/graphql'); console.log('GraphQL Playground running on http://localhost:1337/playground'); });

And finally start your app:

$ npx mongodb-runner start $ node index.js

After starting the app, you can visit http://localhost:1337/playground in your browser to start playing with your GraphQL API.

Note: Do NOT mount the GraphQL Playground in production. Parse Dashboard has a built-in GraphQL Playground and it is the recommended option for production apps.

Checking the API health

Run the following:

query Health { health }

You should receive the following response:

{ "data": { "health": true } }

Creating your first class

Since your application does not have any schema yet, you can use the


mutation to create your first class. Run the following:

mutation CreateClass { createClass( name: "GameScore" schemaFields: { addStrings: [{ name: "playerName" }] addNumbers: [{ name: "score" }] addBooleans: [{ name: "cheatMode" }] } ) { name schemaFields { name \_\_typename } } }

You should receive the following response:

{ "data": { "createClass": { "name": "GameScore", "schemaFields": [{ "name": "objectId", "\_\_typename": "SchemaStringField" }, { "name": "updatedAt", "\_\_typename": "SchemaDateField" }, { "name": "createdAt", "\_\_typename": "SchemaDateField" }, { "name": "playerName", "\_\_typename": "SchemaStringField" }, { "name": "score", "\_\_typename": "SchemaNumberField" }, { "name": "cheatMode", "\_\_typename": "SchemaBooleanField" }, { "name": "ACL", "\_\_typename": "SchemaACLField" }] } } }

Using automatically generated operations

Parse Server learned from the first class that you created and now you have the


class in your schema. You can now start using the automatically generated operations!

Run the following to create your first object:

mutation CreateGameScore { createGameScore( fields: { playerName: "Sean Plott" score: 1337 cheatMode: false } ) { id updatedAt createdAt playerName score cheatMode ACL } }

You should receive a response similar to this:

{ "data": { "createGameScore": { "id": "XN75D94OBD", "updatedAt": "2019-09-17T06:50:26.357Z", "createdAt": "2019-09-17T06:50:26.357Z", "playerName": "Sean Plott", "score": 1337, "cheatMode": false, "ACL": null } } }

You can also run a query to this new class:

query GameScores { gameScores { results { id updatedAt createdAt playerName score cheatMode ACL } } }

You should receive a response similar to this:

{ "data": { "gameScores": { "results": [{ "id": "XN75D94OBD", "updatedAt": "2019-09-17T06:50:26.357Z", "createdAt": "2019-09-17T06:50:26.357Z", "playerName": "Sean Plott", "score": 1337, "cheatMode": false, "ACL": null }] } } }

Customizing your GraphQL Schema

Parse GraphQL Server allows you to create a custom GraphQL schema with own queries and mutations to be merged with the auto-generated ones. You can resolve these operations using your regular cloud code functions.

To start creating your custom schema, you need to code a


file and initialize Parse Server with





$ parse-server --appId APPLICATION\_ID --masterKey MASTER\_KEY --databaseURI mongodb://localhost/test --publicServerURL http://localhost:1337/parse --cloud ./cloud/main.js --graphQLSchema ./cloud/schema.graphql --mountGraphQL --mountPlayground

Creating your first custom query

Use the code below for your




files. Then restart your Parse Server.

# schema.graphql extend type Query { hello: String! @resolve }
// main.js Parse.Cloud.define('hello', async () =\> { return 'Hello world!'; });

You can now run your custom query using GraphQL Playground:

query { hello }

You should receive the response below:

{ "data": { "hello": "Hello world!" } }

Learning more

The Parse GraphQL Guide is a very good source for learning how to use the Parse GraphQL API.

You also have a very powerful tool inside your GraphQL Playground. Please look at the right side of your GraphQL Playground. You will see the




menus. They are automatically generated by analyzing your application schema. Please refer to them and learn more about everything that you can do with your Parse GraphQL API.

Additionally, the GraphQL Learn Section is a very good source to learn more about the power of the GraphQL language.

Upgrading to 3.0.0

Starting 3.0.0, parse-server uses the JS SDK version 2.0. In short, parse SDK v2.0 removes the backbone style callbacks as well as the Parse.Promise object in favor of native promises. All the Cloud Code interfaces also have been updated to reflect those changes, and all backbone style response objects are removed and replaced by Promise style resolution.

We have written up a migration guide, hoping this will help you transition to the next major release.


Please take a look at our support document.

If you believe you've found an issue with Parse Server, make sure these boxes are checked before reporting an issue:

Want to ride the bleeding edge?

It is recommend to use builds deployed npm for many reasons, but if you want to use the latest not-yet-released version of parse-server, you can do so by depending directly on this branch:

npm install parse-community/parse-server.git#master


You can also use your own forks, and work in progress branches by specifying them:

npm install github:myUsername/parse-server#my-awesome-feature

And don't forget, if you plan to deploy it remotely, you should run

npm install

with the




We really want Parse to be yours, to see it grow and thrive in the open source community. Please see the Contributing to Parse Server guide.


This project exists thanks to all the people who contribute... we'd love to see your face on this list!


Support this project by becoming a sponsor. Your logo will show up here with a link to your website. Become a sponsor!


Support us with a monthly donation and help us continue our activities. Become a backer!

As of April 5, 2017, Parse, LLC has transferred this code to the parse-community organization, and will no longer be contributing to or distributing this code.

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.