Get started with SashiDo

1. Create an app

Sign up at dashboard.sashido.io and create an app. Pick the region closest to your users. The app is a full Parse Server with its own MongoDB database.

2. Find your keys and URLs

In the dashboard open your app, then App Settings › Security & Keys:

Field	What it's for
Application ID	Identifies the app. Every SDK needs it.
Client Key	iOS, Android and Flutter apps.
JavaScript Key	Web and React Native apps.
.NET Key	Windows, Xamarin and Unity apps.
REST API Key	Server-side REST calls. Keep it secret.
Master Key	Overrides every permission. Server-side only. Keep it secret.
API URL Address	https://pg-app-<id>.scalabl.cloud/1/: the SDKs' server URL.
LiveQuery URL Address	wss://pg-app-<id>.scalabl.cloud/1/: real-time subscriptions.
GraphQL API URL	https://pg-app-<id>.scalabl.cloud/graphql (Parse Server 3.5 and newer).
Files URL (CDN)	Where uploaded files are served from.

The client keys (Client, JavaScript, .NET) ship inside your app, so anyone can read them. What protects your data is class-level permissions and ACLs, not hidden keys: see Secure your app. The master key bypasses all of that, so it never goes in a client, a repository or a prompt. For scripts and AI assistants, use an access token instead.

3. Connect your app

Any Parse SDK works. Pick yours; each block installs the SDK and connects it.

JavaScript (web, Vue, React, Next.js)

npm install parse

import Parse from 'parse';

Parse.initialize('YOUR_APP_ID', 'YOUR_JAVASCRIPT_KEY');
Parse.serverURL = 'https://pg-app-<id>.scalabl.cloud/1/';

In server-side code (Node.js, Next.js API routes) import parse/node instead. With Vite and other bundlers that don't provide Node's built-in modules, also run npm install events: the SDK needs EventEmitter, and without it the app fails with "Emitter is not a constructor".

React Native

npm install parse @react-native-async-storage/async-storage

import Parse from 'parse/react-native.js';
import AsyncStorage from '@react-native-async-storage/async-storage';

Parse.setAsyncStorage(AsyncStorage);
Parse.initialize('YOUR_APP_ID', 'YOUR_JAVASCRIPT_KEY');
Parse.serverURL = 'https://pg-app-<id>.scalabl.cloud/1/';

Flutter

flutter pub add parse_server_sdk_flutter

import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

await Parse().initialize(
  'YOUR_APP_ID',
  'https://pg-app-<id>.scalabl.cloud/1/',
  clientKey: 'YOUR_CLIENT_KEY',
  autoSendSessionId: true,
);

The Dart SDK sends the Client Key. Sign-up without an email needs signUp(allowWithoutEmail: true). For Flutter web, the app has to run Parse Server 4.1 or newer: SashiDo allows the SDK's headers (X-Parse-Client-Key, X-Parse-Installation-Id) in CORS from there. iOS and Android apps don't need this.

iOS and macOS (Swift)

Add https://github.com/netreconlab/Parse-Swift with Swift Package Manager, then:

import ParseSwift

ParseSwift.initialize(
  applicationId: "YOUR_APP_ID",
  clientKey: "YOUR_CLIENT_KEY",
  serverURL: URL(string: "https://pg-app-<id>.scalabl.cloud/1/")!
)

Android (Java or Kotlin)

Add the Parse Android SDK from JitPack, then in your Application:

Parse.initialize(
  Parse.Configuration.Builder(this)
    .applicationId("YOUR_APP_ID")
    .clientKey("YOUR_CLIENT_KEY")
    .server("https://pg-app-<id>.scalabl.cloud/1/")
    .build()
)

PHP (server side)

composer require parse/php-sdk

use Parse\ParseClient;

ParseClient::initialize('YOUR_APP_ID', 'YOUR_REST_API_KEY', 'YOUR_MASTER_KEY');
ParseClient::setServerURL('https://pg-app-<id>.scalabl.cloud', '1');

Other platforms

.NET, Xamarin and Unity use the .NET Key; any language can call the REST API with the REST API Key, or the GraphQL API.

4. Check that it works

Save an object from your app, or from a terminal:

curl -X POST https://pg-app-<id>.scalabl.cloud/1/classes/TestObject \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"hello": "SashiDo"}'

{ "objectId": "Ab12Cd34Ef", "createdAt": "2026-11-13T10:00:00.000Z" }

Open Core › Browser in the dashboard: the TestObject class is there with your object. Classes are created on the first save while Allow client class creation is on (App Settings › Security & Keys). Once your classes are defined, turn it off.

5. Add cloud code

Cloud code is server-side JavaScript that runs next to your data: functions your clients call, triggers on save and delete, and background jobs.

Every app has a private GitHub repository for its cloud code. In the dashboard open Core › Cloud Code, link your GitHub account and accept the invitation to the repository. Then clone it, edit cloud/main.js, and push: SashiDo builds and deploys the new version.

// cloud/main.js
Parse.Cloud.define('hello', async (request) => {
  return `Hello, ${request.params.name || 'world'}!`;
});

Parse.Cloud.beforeSave('Note', async (request) => {
  if (!request.object.get('text')) {
    throw new Parse.Error(Parse.Error.VALIDATION_ERROR, 'A note needs text.');
  }
});

Call it from a client:

const greeting = await Parse.Cloud.run('hello', { name: 'Ada' });

Write cloud code for the Parse Server version your app runs (shown in Runtime › Parse Server Version). Since Parse Server 3, functions are async and return their result, with no response.success. The MCP server can check your code against your version and plan an upgrade.

Start from a working app

Ready-made apps with sign-up, login and a private, live todo list, built the way this guide describes (ACLs set in cloud code, a locked-down class, Live Queries):

• sashido-react-starter: React + Vite.
• sashido-react-native-starter: React Native with Expo, for iOS, Android and the web.
• sashido-flutter-starter: Flutter, for iOS, Android and the web.

Each README walks you through connecting it to your app.

6. Next steps

• Create an access token to work with your app from scripts and AI assistants.
• Connect your AI assistant to read the schema, query data, deploy and debug from your editor.
• Make it fast before your users find out it isn't.