# Parse JS SDK: one npm package with entry points for Node, React Native, browsers and WeChat

> The Parse JavaScript SDK is the client half of the Parse Platform, published as the single `parse` npm package with per-platform entry points, a swappable Core Manager and a strict pairing rule between SDK and server versions.

**parse-community/Parse-SDK-JS** — The JavaScript SDK for Parse Platform

- Repository: https://github.com/parse-community/Parse-SDK-JS
- Website: https://parseplatform.org
- Stars: 1,342 · Forks: 599
- Language: JavaScript
- License: Apache-2.0
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/parse-community-parse-sdk-js

## The npm package splits by runtime through its exports map

The package on npm is called `parse`, and its package.json publishes one bundle with several entry points rather than several packages. The exports map lists the default index, a `./node` target, `./react-native`, `./react-native.js` and `./weapp`, plus wildcard paths for `./dist/*` and `./lib/*` and two specific lib files for the Node promise utilities and the Node REST controller. TypeScript definitions ship in the same package under `types/`, with a separate `typesVersions` entry pointing Node and React Native users at different declaration files. The published file list includes `index.js`, `node.js`, `react-native.js`, `weapp.js`, the `dist/` and `lib/` folders, and the license and notice files. The reason for the split is stated plainly in the documentation: not every feature makes sense in every execution environment, so local storage, user sessions and HTTP requests need different dependencies depending on where the code runs.

## The Core Manager is the seam where you replace behaviour

Everything the SDK does can be reconfigured through one object, the Core Manager, which holds all configuration and controllers. The modules can be swapped before the SDK is initialized, which is what makes the customization story possible without forking the library. The documented configuration example sets a request attempt limit, and the controller example replaces the REST controller with your own implementation.

```js
// Configuration example
Parse.CoreManager.set('REQUEST_ATTEMPT_LIMIT', 1)

// Controller example
Parse.CoreManager.setRESTController(MyRESTController);
```

That is a real extension point rather than a cosmetic one: a team that needs different retry behaviour, different transport, or its own instrumentation can supply a controller and have every request flow through it. The full list of swappable modules lives in separate Core Manager documentation rather than in the README, so the number of available slots is not something the README enumerates.

## Storage backend is chosen by the entry point you import

The browser and web worker build defaults to the normal module import, while a pre-compiled development file and a minified production file are also served from unpkg. IndexedDB is available for web worker and browser applications and is installed through the Core Manager. Node.js applications and command line tools import `parse/node`, and WeChat mini programs import `parse/weapp`, with matching unpkg builds for that environment. React Native has its own entry point plus one extra step: on React Native 0.50 and later with Parse 1.11.0 and later, the AsyncStorage implementation is passed in explicitly with `Parse.setAsyncStorage`. Server side rendered applications set the `SERVER_RENDERING` variable to keep runtime warnings quiet. The pattern is consistent: local storage and session handling differ per platform, and the entry point is what wires in the right dependency.

## Version pairing with Parse Server is a hard constraint

The SDK publishes a two-line compatibility table for the server. SDK versions from 4.0.0 up to but not including 5.0.0 pair with Parse Server versions from 6.0.0 up to but not including 7.0.0, and SDK 5.0.0 and later require Parse Server 7.0.0 and later. That table is the first thing to read before pinning anything, because a mismatch means the SDK talks to a server it was not written for. Node support follows the Node.js Long Term Support plan, and the table lists Node.js 20, 22 and 24 as compatible with their respective end-of-life dates of April 2026, April 2027 and April 2028. The default branch of the repository is `alpha`, and recent releases include 8.6.2, 8.6.2-alpha.1 and 8.6.1, all dated 2026-09-23, with an auto-release workflow feeding a changelog directory.

## Installing is one npm line, with a pre-compiled path when you want one

The documented route into a JavaScript project is the npm module. In a browser based application you import it the usual way, either with a CommonJS require or as a minimized ES module import.

```js
const Parse = require('parse');
// ES6 Minimized
import Parse from 'parse/dist/parse.min.js';
```

For a server side application or a Node.js command line tool the documentation adds one line to your application code, pointing at the `parse/node` entry point.

```js
// In a node.js environment
const Parse = require('parse/node');
```

For a React Native application the entry point is `parse/react-native.js`, and if your React Native version is 0.50 or later and your Parse version is 1.11.0 or later you also pass the AsyncStorage module in.

```js
// In a React Native application
const Parse = require('parse/react-native.js');

// On React Native >= 0.50 and Parse >= 1.11.0, set the Async
const AsyncStorage = require('@react-native-async-storage/async-storage');
Parse.setAsyncStorage(AsyncStorage);
```

If you would rather not build through a bundler, unpkg serves the development and minified production files directly. There is also a documented route for trying work in progress branches, which installs a fork from GitHub by owner, repository and branch name, with the reminder to use the `--save` option when you intend to deploy remotely.

## Third-party login is a module you write, not a flag you set

Authentication beyond the built-in credentials is handled by linking an external provider. The documentation states that Parse Server supports many third party authentications, that any of them can be linked with the `linkWith` call, and that doing so means creating a custom authentication module. The mechanism is extension by subclass rather than configuration, so a team adding a new provider writes code against the SDK rather than picking an option from a list. This is also where the Core Manager earns its keep, since the storage, session and controller modules behind the SDK are the same ones a custom module plugs into.

## What the package does not carry, and what it costs to stay current

This repository is the client SDK, not the backend. The source tree holds the build and release tooling, a `src/` directory, a `types/` folder, integration tests, an eslint config and a vite config for the UMD bundle, and the published artefact has no server component in it. If you are writing a mobile or web client without a Parse Server to talk to, installing this package gives you nothing to call, and standing up that server is a separate decision with its own cost. The licence is Apache-2.0, with both a LICENSE file and a NOTICE file at the top level of the repository, and the CHANGELOG.md file plus the changelogs directory record release history. The last push to the repository was on 2026-10-17, so the SDK is still being worked on, and the two-line server compatibility table is the piece most likely to force an upgrade decision in your code.

## Conclusion

Pick the Parse JS SDK when your frontend has to talk to a Parse Server you control and you want the same API surface across Node, React Native, the browser and WeChat mini programs. Skip it if you are only writing a client, since the package is the SDK half and the server is a separate deployment you must run yourself. Before pinning a version, check the compatibility table so the SDK line and the Parse Server line match, then decide which entry point your runtime imports.

## FAQ

### Which Node.js versions does the Parse JS SDK support?

Node.js 20, 22 and 24 are marked as compatible in the support table, and the SDK is tested with recent releases that follow the Node.js Long Term Support plan.

### Which Parse Server version works with the current Parse JS SDK?

SDK versions from 5.0.0 onwards require Parse Server 7.0.0 or newer. The older SDK line from 4.0.0 up to 5.0.0 pairs with Parse Server 6.x.

### How do I use the Parse JS SDK in a React Native app?

Import the `parse/react-native.js` entry point. On React Native 0.50 and later with Parse 1.11.0 and later, pass the AsyncStorage module to `Parse.setAsyncStorage`.

### Can the Parse JS SDK use IndexedDB in a browser app?

Yes. For web worker and browser applications the documentation shows installing IndexedDB through the Core Manager with `Parse.CoreManager.setStorageController(Parse.IndexedDB)`.

## Sources

- [License: Apache-2.0](https://github.com/parse-community/Parse-SDK-JS/blob/alpha/LICENSE)
- [parse-community/Parse-SDK-JS on GitHub](https://github.com/parse-community/Parse-SDK-JS)
- [Project website](https://parseplatform.org)
- [README](https://github.com/parse-community/Parse-SDK-JS/blob/alpha/README.md)
- [Releases](https://github.com/parse-community/Parse-SDK-JS/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/parse-community-parse-sdk-js