Quickstarters
How to Build a Backend for MeteorJS?

50min
Introduction
In this tutorial, you’ll learn how to build a complete backend for a MeteorJS application using Back4App. 
We’ll walk through integrating essential Back4App features—such as database management, Cloud Code Functions, REST and GraphQL APIs, user authentication, and real-time queries (Live Queries)—to create a secure, scalable, and robust backend that seamlessly communicates with your MeteorJS application.
You’ll also see how Back4App’s quick setup and intuitive environment can drastically reduce the time and effort compared to manually configuring servers and databases. 
Along the way, you’ll gain hands-on experience with key functionalities, including advanced security features, scheduling tasks with Cloud Jobs, and setting up webhooks for external integrations.
By the end of this tutorial, you’ll be well-prepared to enhance this foundational setup into a production-ready application, or easily incorporate custom logic and third-party APIs as needed.
Prerequisites
To complete this tutorial, you will need:
A Back4App account and a new Back4App project
Getting Started with Back4App.
If you do not have an account, you can create one for free. Follow the guide above to get your project ready.
Basic MeteorJS development environment
Make sure you have Meteor installed. If you don’t, follow the Meteor installation guide.
Node.js (version 14 or above) installed
You will need Node.js for running local development servers. Installing Node.js﻿
Familiarity with JavaScript and basic MeteorJS concepts
MeteorJS Official Documentation.
If you’re new to Meteor, review the official docs or a beginner’s tutorial before starting.
Make sure you have all of these prerequisites in place before you begin. Having your Back4App project set up and your local MeteorJS environment ready will help you follow along more easily.
Step 1 – Setting Up Back4App Project
Create a New Project
The first step in building your MeteorJS backend on Back4App is creating a new project. If you have not already created one, follow these steps:
Log in to your Back4App account.
Click the “New App” button in your Back4App dashboard.
Give your app a name (e.g., “Meteor-Backend-Tutorial”).
﻿
Once the project is created, you will see it listed in your Back4App dashboard. This project will be the foundation for all backend configurations discussed in this tutorial.
Connect the Parse SDK
Back4App relies on the Parse Platform to manage your data, provide real-time features, handle user authentication, and more. Connecting your MeteorJS application to Back4App involves installing the parse npm package and initializing it with the credentials from your Back4App dashboard.
Retrieve your Parse Keys:
In your Back4App dashboard, navigate to your app’s “App Settings” or “Security & Keys” section to find your Application ID and JavaScript Key. You will also find the Parse Server URL (often in the format https://parseapi.back4app.com).
﻿
Install the Parse SDK in your MeteorJS project:
Bash
meteor npm install parse
meteor npm install parse
﻿
Initialize Parse in your MeteorJS application:
You can create a startup file or a configuration file (e.g., parseConfig.js) in a folder that Meteor loads early (such as imports/ or client/compatibility/). One option is to place this code in imports/startup/client/parseConfig.js or a similarly relevant path:
imports/startup/client/parseConfig.js
import Parse from 'parse';

// Replace the placeholders with your Back4App credentials
Parse.initialize('YOUR_APPLICATION_ID', 'YOUR_JAVASCRIPT_KEY');
Parse.serverURL = 'https://parseapi.back4app.com';

export default Parse;
import Parse from 'parse';

// Replace the placeholders with your Back4App credentials
Parse.initialize('YOUR_APPLICATION_ID', 'YOUR_JAVASCRIPT_KEY');
Parse.serverURL = 'https://parseapi.back4app.com';

export default Parse;
﻿
This file ensures that whenever you import Parse elsewhere in your Meteor app, it is pre-configured to connect to your specific Back4App instance.
By completing this step, you have established a secure connection between your MeteorJS front-end (and/or server) and the Back4App backend. All requests and data transactions are securely routed through this SDK, reducing the complexity of manual REST or GraphQL calls (although you can still use them when needed).
Step 2 – Setting Up the Database
Saving and Querying Data
With your Back4App project set up and the Parse SDK integrated into your Meteor app, you can now start saving and retrieving data. The simplest way to create a record is to use the Parse.Object class:
JS
// Example: Create a Todo item

import Parse from '/imports/startup/client/parseConfig.js';

async function createTodoItem(title, isCompleted) {
  const Todo = Parse.Object.extend('Todo');
  const todo = new Todo();
  todo.set('title', title);
  todo.set('isCompleted', isCompleted);

  try {
    const savedTodo = await todo.save();
    console.log('Todo saved successfully:', savedTodo);
    return savedTodo;
  } catch (error) {
    console.error('Error saving Todo:', error);
  }
}

// Example: Query all Todo items

async function fetchTodos() {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);

  try {
    const results = await query.find();
    console.log('Fetched Todo items:', results);
    return results;
  } catch (error) {
    console.error('Error fetching Todos:', error);
  }
}
// Example: Create a Todo item

import Parse from '/imports/startup/client/parseConfig.js';

async function createTodoItem(title, isCompleted) {
  const Todo = Parse.Object.extend('Todo');
  const todo = new Todo();
  todo.set('title', title);
  todo.set('isCompleted', isCompleted);

  try {
    const savedTodo = await todo.save();
    console.log('Todo saved successfully:', savedTodo);
    return savedTodo;
  } catch (error) {
    console.error('Error saving Todo:', error);
  }
}

// Example: Query all Todo items

async function fetchTodos() {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);

  try {
    const results = await query.find();
    console.log('Fetched Todo items:', results);
    return results;
  } catch (error) {
    console.error('Error fetching Todos:', error);
  }
}
﻿
Alternatively, you can use Back4App’s REST API endpoints:
Curl
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
﻿
Back4App also provides a GraphQL interface:
GraphQL
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
﻿
These diverse options let you integrate data operations in the way that best suits your development process—whether that's through the Parse SDK, REST, or GraphQL.
Schema Design and Data Types
By default, Parse allows schema creation on the fly, but you can also define your classes and data types in the Back4App dashboard for more control.
Navigate to the “Database” section in your Back4App dashboard.
Create a new class (e.g., “Todo”) and add relevant columns, such as title (String) and isCompleted (Boolean). 
Create New Class
﻿
Back4App also supports various data types: String, Number, Boolean, Object, Date, File, Pointer, Array, Relation, GeoPoint, and Polygon. You can choose the appropriate type for each field. If you prefer, you can also let Parse automatically create these columns when you first save an object from your Meteor app.
Create Column
﻿
Back4App offers an AI Agent that can help you design your data model:
Open the AI Agent from your App Dashboard or on the menu.
Describe your data model in simple language (e.g., “Please, create a new ToDo App at back4app with a complete class schema.”).
Let the AI Agent create the Schema for you. 
﻿
Using the AI Agent can save you time when setting up your data architecture and ensure consistency across your application.
Relational Data
If you have relational data—say, a Category object that points to multiple Todo items—you can use Pointers or Relations in Parse. For example, adding a pointer to a Category:
JS
// Linking a Task to a Category with a pointer
async function createTaskForCategory(categoryObjectId, title) {
  const todo = new Parse.Object('Todo');
  
  // Construct a pointer to the category
  const categoryPointer = new Parse.Object('Category');
  categoryPointer.id = categoryObjectId;

  // Set fields
  todo.set('title', title);
  todo.set('category', categoryPointer);

  try {
    return await todo.save();
  } catch (err) {
    console.error('Error creating Task with category relationship:', err);
  }
}
// Linking a Task to a Category with a pointer
async function createTaskForCategory(categoryObjectId, title) {
  const todo = new Parse.Object('Todo');
  
  // Construct a pointer to the category
  const categoryPointer = new Parse.Object('Category');
  categoryPointer.id = categoryObjectId;

  // Set fields
  todo.set('title', title);
  todo.set('category', categoryPointer);

  try {
    return await todo.save();
  } catch (err) {
    console.error('Error creating Task with category relationship:', err);
  }
}
﻿
When you query, you can also include pointer data:
JS
const query = new Parse.Query('Todo');
query.include('category');
const todosWithCategory = await query.find();
const query = new Parse.Query('Todo');
query.include('category');
const todosWithCategory = await query.find();
﻿
This include('category') call fetches category details alongside each Todo, making your relational data seamlessly accessible.
Live Queries
For real-time updates, Back4App provides Live Queries. In your MeteorJS app, you can subscribe to changes in a specific class:
Enable Live Queries in your Back4App dashboard under your app’s Server Settings. Make sure “Live Queries” is turned on.
Initialize a Live Query Subscription in your code:
imports/startup/client/parseConfig.js
import Parse from 'parse';

// Replace the placeholders with your Back4App credentials
Parse.initialize('YOUR_APPLICATION_ID', 'YOUR_JAVASCRIPT_KEY');
Parse.serverURL = 'https://parseapi.back4app.com';

// Live Query's subdomain:
Parse.liveQueryServerURL = 'wss://YOUR_SUBDOMAIN_HERE.b4a.io'; 

export default Parse;
import Parse from 'parse';

// Replace the placeholders with your Back4App credentials
Parse.initialize('YOUR_APPLICATION_ID', 'YOUR_JAVASCRIPT_KEY');
Parse.serverURL = 'https://parseapi.back4app.com';

// Live Query's subdomain:
Parse.liveQueryServerURL = 'wss://YOUR_SUBDOMAIN_HERE.b4a.io'; 

export default Parse;
﻿
JS
import Parse from '/imports/startup/client/parseConfig.js';

async function subscribeToTodos(callback) {
  const query = new Parse.Query('Todo');
  const subscription = await query.subscribe();

  subscription.on('create', (newTodo) => {
    console.log('New Todo created:', newTodo);
    callback('create', newTodo);
  });

  subscription.on('update', (updatedTodo) => {
    console.log('Todo updated:', updatedTodo);
    callback('update', updatedTodo);
  });

  subscription.on('delete', (deletedTodo) => {
    console.log('Todo deleted:', deletedTodo);
    callback('delete', deletedTodo);
  });

  return subscription;
}
import Parse from '/imports/startup/client/parseConfig.js';

async function subscribeToTodos(callback) {
  const query = new Parse.Query('Todo');
  const subscription = await query.subscribe();

  subscription.on('create', (newTodo) => {
    console.log('New Todo created:', newTodo);
    callback('create', newTodo);
  });

  subscription.on('update', (updatedTodo) => {
    console.log('Todo updated:', updatedTodo);
    callback('update', updatedTodo);
  });

  subscription.on('delete', (deletedTodo) => {
    console.log('Todo deleted:', deletedTodo);
    callback('delete', deletedTodo);
  });

  return subscription;
}
﻿
By subscribing, you receive real-time notifications whenever a new Todo is created, updated, or deleted. This feature is particularly valuable for collaborative or dynamic apps where multiple users need to see the latest data without refreshing the page.
Step 3 – Applying Security with ACLs and CLPs
Back4App Security Mechanism
Back4App takes security seriously by providing Access Control Lists (ACLs) and Class-Level Permissions (CLPs). These features let you restrict who can read or write data on a per-object or per-class basis, ensuring only authorized users can modify your data.
﻿
Access Control Lists (ACLs)
An ACL is applied to individual objects to determine which users, roles, or the public can perform read/write operations. For example:
JS
async function createPrivateTodo(title, ownerUser) {
  const Todo = Parse.Object.extend('Todo');
  const todo = new Todo();
  todo.set('title', title);

  // Create an ACL granting read/write access only to the owner
  const acl = new Parse.ACL(ownerUser);
  acl.setPublicReadAccess(false);
  acl.setPublicWriteAccess(false);

  todo.setACL(acl);

  try {
    return await todo.save();
  } catch (err) {
    console.error('Error saving private todo:', err);
  }
}
async function createPrivateTodo(title, ownerUser) {
  const Todo = Parse.Object.extend('Todo');
  const todo = new Todo();
  todo.set('title', title);

  // Create an ACL granting read/write access only to the owner
  const acl = new Parse.ACL(ownerUser);
  acl.setPublicReadAccess(false);
  acl.setPublicWriteAccess(false);

  todo.setACL(acl);

  try {
    return await todo.save();
  } catch (err) {
    console.error('Error saving private todo:', err);
  }
}
﻿
When you save the object, it has an ACL that prevents anyone but the specified user from reading or modifying it.
Edit ACL
﻿
Class-Level Permissions (CLPs)
CLPs govern an entire class’s default permissions, such as whether the class is publicly readable or writable, or if only certain roles can access it.
Go to your Back4App Dashboard, select your app, and open the Database section.
Select a class (e.g., “Todo”).
Open the Class-Level Permissions tab. 
Configure your defaults, such as “Requires Authentication” for read or write, or “No Access” for the public.
﻿
These permissions set the baseline, while ACLs fine-tune permissions for individual objects. A robust security model typically combines both CLPs (broad restrictions) and ACLs (fine-grained per-object restrictions). For more information go to App Security Guidelines.﻿
Step 4 – Writing and Deploying Cloud Functions
Cloud Code is a feature of the Parse Server environment that allows you to run custom JavaScript code on the server side—without needing to manage your servers or infrastructure. By writing Cloud Code, you can extend your Back4App backend with additional business logic, validations, triggers, and integrations that run securely and efficiently on the Parse Server.
How It Works
When you write Cloud Code, you typically place your JavaScript functions, triggers, and any required NPM modules in a main.js (or app.js) file. This file is then deployed to your Back4App project, which is executed within the Parse Server environment. Since these functions and triggers run on the server, you can trust them to handle confidential logic, process sensitive data, or make backend-only API calls—processes you might not want to expose directly to the client.
All Cloud Code for your Back4App app runs inside the Parse Server that is managed by Back4App, so you don’t have to worry about server maintenance, scaling, or provisioning. Whenever you update and deploy your main.js file, the running Parse Server is updated with your latest code.
main.js File Structure
A typical main.js might contain:
Require statements for any needed modules (NPM packages, built-in Node modules, or other cloud code files).
Cloud function definitions using Parse.Cloud.define().
Triggers such as Parse.Cloud.beforeSave(), Parse.Cloud.afterSave(), etc.
NPM modules you installed (if needed). For example, you might install a package like axios to make HTTP requests. You can then require (or import) it at the top of your file.
JS
// main.js

// 1. Import necessary modules and other cloud code files
const axios = require('axios');
const report = require('./reports');

// 2. Define a custom Cloud Function
Parse.Cloud.define('fetchExternalData', async (request) => {
  const url = request.params.url;
  if (!url) {
    throw new Error('URL parameter is required');
  }
  const response = await axios.get(url);
  return response.data;
});

// 3. Example of a beforeSave trigger
Parse.Cloud.beforeSave('Todo', (request) => {
  const todo = request.object;
  if (!todo.get('title')) {
    throw new Error('Todo must have a title');
  }
});
// main.js

// 1. Import necessary modules and other cloud code files
const axios = require('axios');
const report = require('./reports');

// 2. Define a custom Cloud Function
Parse.Cloud.define('fetchExternalData', async (request) => {
  const url = request.params.url;
  if (!url) {
    throw new Error('URL parameter is required');
  }
  const response = await axios.get(url);
  return response.data;
});

// 3. Example of a beforeSave trigger
Parse.Cloud.beforeSave('Todo', (request) => {
  const todo = request.object;
  if (!todo.get('title')) {
    throw new Error('Todo must have a title');
  }
});
﻿
With the ability to install and use NPM modules, Cloud Code becomes incredibly flexible, allowing you to integrate with external APIs, perform data transformations, or execute complex server-side logic.
Typical Use Cases
Business Logic: For example, you may calculate a user’s score in a game by aggregating multiple object properties, and then store that data automatically.
Data Validations: Ensure certain fields are present or that a user has correct permissions before saving or deleting a record.
Triggers: Perform actions when data changes (e.g., send a notification when a user updates their profile).
Integrations: Connect with third-party APIs or services. For example, you could integrate with payment gateways, Slack notifications, or email marketing platforms directly from Cloud Code.
Security Enforcement: Add an extra layer of security by validating and sanitizing input parameters in your Cloud Code functions.
Deploy Your Function
Below is a simple Cloud Code function that calculates the length of a text string sent from the client:
main.js
// main.js

Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
// main.js

Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
﻿
Deploying via the Back4App CLI:
1 - Install the CLI:
For Linux/MacOS:
Bash
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash
﻿
For Windows:
Download the b4a.exe file from the releases page.
2 - Configure your account key:﻿
Bash
b4a configure accountkey
b4a configure accountkey
﻿
3 - Deploy your cloud code:
Bash
b4a deploy
b4a deploy
﻿
Deploying through the Dashboard:
In your app’s dashboard, go to Cloud Code > Functions.
Copy/paste the function into the main.js editor.
Click Deploy.
﻿
Calling Your Function
From MeteorJS using the Parse SDK (for instance, in a client method or after a user action):
JS
import Parse from '/imports/startup/client/parseConfig.js';

async function getTextLength(text) {
  try {
    const result = await Parse.Cloud.run('calculateTextLength', { text });
    console.log('Text length:', result.length);
  } catch (err) {
    console.error('Error calling cloud function:', err);
  }
}
import Parse from '/imports/startup/client/parseConfig.js';

async function getTextLength(text) {
  try {
    const result = await Parse.Cloud.run('calculateTextLength', { text });
    console.log('Text length:', result.length);
  } catch (err) {
    console.error('Error calling cloud function:', err);
  }
}
﻿
You can also call it via REST:
Curl
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello Back4app"}' \
  https://parseapi.back4app.com/functions/calculateTextLength
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello Back4app"}' \
  https://parseapi.back4app.com/functions/calculateTextLength
﻿
Or via GraphQL:
GraphQL
mutation {
  calculateTextLength(input: {
    text: "Hello GraphQL"
  }) {
    result
  }
}
mutation {
  calculateTextLength(input: {
    text: "Hello GraphQL"
  }) {
    result
  }
}
﻿
This flexibility enables you to integrate your custom logic into your MeteorJS app or any other client that supports REST or GraphQL.
Step 5 – Configuring User Authentication
User Authentication in Back4App
Back4App leverages the Parse User class as the foundation for authentication. By default, Parse handles password hashing, session tokens, and secure storage. This means you don’t have to set up complex security flows manually.
Setting Up User Authentication
In a MeteorJS application, you can create a new user with:
JS
import Parse from '/imports/startup/client/parseConfig.js';

async function signUpUser(username, password, email) {
  const user = new Parse.User();
  user.set('username', username);
  user.set('password', password);
  user.set('email', email);

  try {
    await user.signUp();
    console.log('User signed up successfully!');
  } catch (error) {
    console.error('Error signing up user:', error);
  }
}

async function logInUser(username, password) {
  try {
    const user = await Parse.User.logIn(username, password);
    console.log('User logged in:', user);
  } catch (error) {
    console.error('Error logging in user:', error);
  }
}
import Parse from '/imports/startup/client/parseConfig.js';

async function signUpUser(username, password, email) {
  const user = new Parse.User();
  user.set('username', username);
  user.set('password', password);
  user.set('email', email);

  try {
    await user.signUp();
    console.log('User signed up successfully!');
  } catch (error) {
    console.error('Error signing up user:', error);
  }
}

async function logInUser(username, password) {
  try {
    const user = await Parse.User.logIn(username, password);
    console.log('User logged in:', user);
  } catch (error) {
    console.error('Error logging in user:', error);
  }
}
﻿
Via REST, a login might look like:
Bash
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -G \
  --data-urlencode 'username=alice' \
  --data-urlencode 'password=secret123' \
  https://parseapi.back4app.com/login
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -G \
  --data-urlencode 'username=alice' \
  --data-urlencode 'password=secret123' \
  https://parseapi.back4app.com/login
﻿
Session Management
After a successful login, Parse creates a session token that is stored in the user object. In your MeteorJS app, you can access the currently logged-in user:
JS
const currentUser = Parse.User.current();
if (currentUser) {
  console.log('Currently logged-in user:', currentUser.getUsername());
} else {
  console.log('No user is logged in');
}
const currentUser = Parse.User.current();
if (currentUser) {
  console.log('Currently logged-in user:', currentUser.getUsername());
} else {
  console.log('No user is logged in');
}
﻿
Parse automatically handles token-based sessions in the background, but you can also manually manage or revoke them. This is useful when you need to log out:
JS
await Parse.User.logOut();
await Parse.User.logOut();
﻿
Social Login Integration
Back4App and Parse can integrate with popular OAuth providers, such as Google or Facebook, by installing additional packages or using existing adapters. For example, you can set up a Facebook login by configuring your Facebook App ID and using Parse.FacebookUtils.logIn(). Detailed instructions vary, so refer to the Social Login Docs.﻿
JS
const facebookLogin = async () => {
  try {
    const user = await Parse.FacebookUtils.logIn('email');
    console.log(user.existed() ? 'User logged in' : 'User signed up and logged in');
  } catch (error) {
    console.error('Error logging in with Facebook:', error);
  }
};
const facebookLogin = async () => {
  try {
    const user = await Parse.FacebookUtils.logIn('email');
    console.log(user.existed() ? 'User logged in' : 'User signed up and logged in');
  } catch (error) {
    console.error('Error logging in with Facebook:', error);
  }
};
﻿
Email Verification and Password Reset
To enable email verification and password reset:
Navigate to the Email Settings in your Back4App dashboard.
Enable email verification to ensure new users verify ownership of their email addresses.
Configure the From address, email templates, and your custom domain if desired.
These features improve account security and user experience by validating user ownership of emails and providing a secure password-recovery method.
Step 6 – Handling File Storage
Uploading and Retrieving Files
Parse includes the Parse.File class for handling file uploads, which Back4App stores securely:
JS
import Parse from '/imports/startup/client/parseConfig.js';

async function uploadImage(file) {
  // file is typically from an <input type="file" ... /> in a Meteor template or React-like UI
  const name = file.name;
  const parseFile = new Parse.File(name, file);

  try {
    const savedFile = await parseFile.save();
    console.log('File saved:', savedFile.url());
    return savedFile.url();
  } catch (err) {
    console.error('Error uploading file:', err);
  }
}

async function createPhotoObject(file) {
  const Photo = Parse.Object.extend('Photo');
  const photo = new Photo();
  const parseFile = new Parse.File(file.name, file);
  photo.set('imageFile', parseFile);

  return await photo.save();
}
import Parse from '/imports/startup/client/parseConfig.js';

async function uploadImage(file) {
  // file is typically from an <input type="file" ... /> in a Meteor template or React-like UI
  const name = file.name;
  const parseFile = new Parse.File(name, file);

  try {
    const savedFile = await parseFile.save();
    console.log('File saved:', savedFile.url());
    return savedFile.url();
  } catch (err) {
    console.error('Error uploading file:', err);
  }
}

async function createPhotoObject(file) {
  const Photo = Parse.Object.extend('Photo');
  const photo = new Photo();
  const parseFile = new Parse.File(file.name, file);
  photo.set('imageFile', parseFile);

  return await photo.save();
}
﻿
Retrieving the file URL is straightforward:
JS
const imageFile = photo.get('imageFile');
const imageUrl = imageFile.url();
const imageFile = photo.get('imageFile');
const imageUrl = imageFile.url();
﻿
You can display this imageUrl in your Meteor templates or front-end components by setting it as the src of an <img> tag.
File Security
Parse Server provides flexible configurations to manage file upload security. The following example shows how you can set permissions to control who can upload files to the server:
{
"fileUpload": {
"enableForPublic": true,
"enableForAnonymousUser": true,
"enableForAuthenticatedUser": true
}
}
enableForPublic: When set to true, allows anyone, regardless of authentication status, to upload files.
enableForAnonymousUser: Controls whether anonymous users (not signed up) can upload files.
enableForAuthenticatedUser: Specifies whether only authenticated users can upload files.
Step 7 – Scheduling Tasks with Cloud Jobs
Cloud Jobs
Cloud Jobs in Back4App let you schedule and run routine tasks on your backend—like cleaning up old data or sending a daily summary email. A typical Cloud Job might look like this:
JS
// main.js

Parse.Cloud.job('cleanupOldTodos', async (request) => {
  // This runs in the background, not triggered by a direct user request
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);

  // For example, remove todos older than 30 days
  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);

  query.lessThan('createdAt', cutoff);

  try {
    const oldTodos = await query.find({ useMasterKey: true });
    await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
    return `Deleted ${oldTodos.length} old Todos.`;
  } catch (err) {
    throw new Error('Error during cleanup:' + err.message);
  }
});
// main.js

Parse.Cloud.job('cleanupOldTodos', async (request) => {
  // This runs in the background, not triggered by a direct user request
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);

  // For example, remove todos older than 30 days
  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);

  query.lessThan('createdAt', cutoff);

  try {
    const oldTodos = await query.find({ useMasterKey: true });
    await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
    return `Deleted ${oldTodos.length} old Todos.`;
  } catch (err) {
    throw new Error('Error during cleanup:' + err.message);
  }
});
﻿
Deploy your Cloud Code with the new job (via CLI or the dashboard).
Go to the Back4App Dashboard > App Settings > Server Settings > Background Jobs. 
Schedule the job to run daily or at whatever interval suits your needs.
Scheduling a Cloud Job
﻿
Cloud Jobs enable you to automate background maintenance or other periodic processes—without requiring manual intervention.
Step 8 – Integrating Webhooks
Webhooks allow your Back4App app to send HTTP requests to an external service whenever certain events occur. This is powerful for integrating with third-party systems like payment gateways (e.g., Stripe), email marketing tools, or analytics platforms.
Navigate to the Webhooks configuration in your Back4App dashboard > More > WebHooks and then click on Add Webhook.
Set up an endpoint (e.g., https://your-external-service.com/webhook-endpoint).
Configure triggers to specify which events in your Back4App classes or Cloud Code functions will fire the webhook.
Adding a Webhook
﻿
For instance, if you want to notify a Slack channel whenever a new Todo is created:
Create a Slack App that accepts incoming webhooks.
Copy the Slack webhook URL.
In your Back4App dashboard, set the endpoint to that Slack URL for the event “New record in the Todo class.”
You can also add custom HTTP headers or payloads if needed.
You can also define Webhooks in Cloud Code by making custom HTTP requests in triggers like beforeSave, afterSave:
BeforeSave WebHook
﻿
Step 9 – Exploring the Back4App Admin Panel
The Back4App Admin App is a web-based management interface designed for non-technical users to perform CRUD operations and handle routine data tasks without writing any code. It provides a model-centric, user-friendly interface that streamlines database administration, custom data management, and enterprise-level operations.
Enabling the Admin App
Enable it going to App Dashboard > More > Admin App and clicking on the “Enable Admin App” button. 
Enable Admin App
﻿
Create a First Admin User (username/password), which automatically generates a new role (B4aAdminUser) and classes (B4aSetting, B4aMenuItem, and B4aCustomField) in your app’s schema.
﻿
Choose a Subdomain for accessing the admin interface and complete the setup.
﻿
Log In using the admin credentials you created to access your new Admin App dashboard.
﻿
Once enabled, the Back4App Admin App makes it easy to view, edit, or remove records from your database—without requiring direct use of the Parse Dashboard or backend code. With configurable access controls, you can safely share this interface with team members or clients who need a clear, point-and-click way to manage data.
Conclusion
By following this comprehensive tutorial, you have:
Created a secure backend for a MeteorJS app on Back4App.
Configured a database with class schemas, data types, and relationships.
Integrated real-time queries (Live Queries) for immediate data updates.
Applied security measures using ACLs and CLPs to protect and manage data access.
Implemented Cloud Code functions to run custom business logic on the server side.
Set up user authentication with support for email verification and password resets.
Managed file uploads and retrieval, with optional file security controls.
Scheduled Cloud Jobs for automated background tasks.
Used Webhooks to integrate with external services.
Explored the Back4App Admin Panel for data management.
With a solid MeteorJS platform and a robust Back4App backend, you are now well-equipped to develop feature-rich, scalable, and secure applications. Continue exploring more advanced functionalities, integrate your business logic, and harness the power of Back4App to save you countless hours in server and database administration. Happy coding!
Next Steps
Build a production-ready MeteorJS app by extending this backend to handle more complex data models, caching strategies, and performance optimizations.
Integrate advanced features such as specialized authentication flows, role-based access control, or external APIs (like payment gateways).
Check out Back4App’s official documentation for deeper dives into advanced security, performance tuning, and logs analysis.
Explore other tutorials on real-time chat applications, IoT dashboards, or location-based services. You can combine the techniques learned here with third-party APIs to create complex, real-world applications.
﻿
Updated 14 Jan 2025
Did this page help you?
How to Build a Backend for ExpressJS?
How to Build a Backend for BackboneJS?