---
title: Get started with SashiDo
group: Build your app
nav: Get started
updated: 2026-11-13
description: Create a Parse Server app on SashiDo, connect your web or mobile app with the Parse SDK, and deploy cloud code from GitHub.
keywords: sashido getting started, parse server tutorial, parse javascript sdk, parse server cloud code, deploy parse server, parse server hosting
---

## 1. Create an app

Sign up at [dashboard.sashido.io](https://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](/en/docs/developers/security). 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](/en/docs/developers/authenticate) 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)

```bash
npm install parse
```

```javascript
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

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

```javascript
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

```bash
flutter pub add parse_server_sdk_flutter
```

```dart
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:

```swift
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](https://github.com/parse-community/Parse-SDK-Android) from JitPack, then in your `Application`:

```kotlin
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)

```bash
composer require parse/php-sdk
```

```php
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](https://docs.parseplatform.org/dotnet/guide/) use the .NET Key; any language can call the [REST API](https://docs.parseplatform.org/rest/guide/) with the REST API Key, or the [GraphQL API](/en/docs/developers/graphql).

## 4. Check that it works

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

```bash
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"}'
```

```json
{ "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.

```javascript
// 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:

```javascript
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](/en/docs/developers/mcp) 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](https://github.com/sashido/sashido-react-starter): React + Vite.
- [sashido-react-native-starter](https://github.com/sashido/sashido-react-native-starter): React Native with Expo, for iOS, Android and the web.
- [sashido-flutter-starter](https://github.com/sashido/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](/en/docs/developers/authenticate) to work with your app from scripts and AI assistants.
- [Connect your AI assistant](/en/docs/developers/mcp) to read the schema, query data, deploy and debug from your editor.
- [Make it fast](/en/docs/developers/performance) before your users find out it isn't.