Contact

How to Use Parse As a Mobile Backend for iOS

4 minutes to read

Use Parse as a backend for your iOS app by integrating the Parse SDK, configuring ParseClientConfiguration, and using PFQuery for data operations.

Setting Up a Parse Backend on Back4App

Sign up for a free account at Back4App. Click Build New App and select Backend Platform. Name your app and create it. Navigate to Database to access the Parse Dashboard for schema management.

Create a data class by clicking Create a Class. For a travel app, create a Trip class with columns: city (String), country (String), featuredImage (File), price (Number), totalDays (Number), and isLiked (Boolean). Parse automatically generates objectId, createdAt, and updatedAt for every record.

Installing the Parse SDK with CocoaPods

Add Parse to your Podfile:

target 'TripCard' do
  use_frameworks!
  pod 'Parse'
end

Run pod install and open the .xcworkspace file.

Configuring Parse Client in AppDelegate

Find your Application ID and Client Key in Back4App under App Settings > Security & Keys. Configure Parse in AppDelegate.swift:

import Parse

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    let config = ParseClientConfiguration {
        $0.applicationId = "YOUR_APP_ID"
        $0.clientKey = "YOUR_CLIENT_KEY"
        $0.server = "https://parseapi.back4app.com"
    }
    Parse.initialize(with: config)
    return true
}

Never commit your Application ID and Client Key to version control. Store them in a configuration file or use environment variables with a .xcconfig file.

Querying Data with PFQuery

Use PFQuery to fetch objects from Parse:

let query = PFQuery(className: "Trip")
query.findObjectsInBackground { objects, error in
    if let error = error {
        print("Query error: (error.localizedDescription)")
        return
    }
    guard let objects = objects else { return }
}

findObjectsInBackground runs asynchronously and returns an array of PFObject instances on a background thread. Dispatch UI updates to the main queue.

Mapping PFObject to Your Model

Create a model initializer that converts PFObject to your Swift type:

import Parse

struct Trip: Hashable {
    let tripId: String
    var city: String
    var country: String
    var featuredImage: PFFileObject?
    var price: Int
    var totalDays: Int
    var isLiked: Bool

    init(pfObject: PFObject) {
        self.tripId = pfObject.objectId!
        self.city = pfObject["city"] as! String
        self.country = pfObject["country"] as! String
        self.price = pfObject["price"] as! Int
        self.totalDays = pfObject["totalDays"] as! Int
        self.featuredImage = pfObject["featuredImage"] as? PFFileObject
        self.isLiked = pfObject["isLiked"] as! Bool
    }

    func toPFObject() -> PFObject {
        let object = PFObject(className: "Trip")
        object.objectId = tripId
        object["city"] = city
        object["country"] = country
        object["featuredImage"] = featuredImage
        object["price"] = price
        object["totalDays"] = totalDays
        object["isLiked"] = isLiked
        return object
    }
}

Loading Images Asynchronously

Parse stores images as PFFileObject. Load them in the background:

cell.imageView.image = UIImage()
if let imageFile = trip.featuredImage {
    imageFile.getDataInBackground { data, error in
        guard let data = data else { return }
        DispatchQueue.main.async {
            cell.imageView.image = UIImage(data: data)
        }
    }
}

Enabling Offline Caching

Parse supports built-in caching with one line of code:

query.cachePolicy = .networkElseCache

The .networkElseCache policy tries the network first and falls back to cached data. Other policies include .ignoreCache, .cacheOnly, .networkOnly, and .cacheElseNetwork.

Saving and Updating Data

Use saveInBackground to persist changes:

func didLikeButtonPressed(cell: TripCell) {
    guard let indexPath = collectionView.indexPath(for: cell) else { return }
    trips[indexPath.row].isLiked.toggle()
    cell.isLiked = trips[indexPath.row].isLiked

    trips[indexPath.row].toPFObject().saveInBackground { success, error in
        if success {
            print("Trip updated successfully")
        } else if let error = error {
            print("Save error: (error.localizedDescription)")
        }
    }
}

The toPFObject() method preserves the objectId so Parse identifies the existing record and updates it rather than creating a new one.

Deleting Data from Parse

Use deleteInBackground to remove objects:

func didTrashButtonPressed(cell: TripCell) {
    guard let indexPath = collectionView.indexPath(for: cell),
          let trip = dataSource.itemIdentifier(for: indexPath) else { return }

    trips[indexPath.row].toPFObject().deleteInBackground { success, error in
        if success {
            var snapshot = self.dataSource.snapshot()
            snapshot.deleteItems([trip])
            self.dataSource.apply(snapshot)
        }
    }
}

Best Practices for Parse Backends

Set appropriate class permissions in the Parse Dashboard. Public Read and Write is convenient for development but insecure for production. Use authenticated read/write for user-specific data.

Cache aggressively. Enable .networkElseCache or .cacheElseNetwork for data that changes infrequently. Caching improves load times and enables offline access.

Handle network errors with user-friendly messages. Raw error descriptions confuse users. Display "Unable to connect. Please check your internet connection." instead of API error codes.

Batch operations for performance. Use PFObject.saveAll(inBackground:) and PFObject.deleteAll(inBackground:) when modifying multiple records.

Implement pagination with limit and skip. Large datasets slow down queries. Fetch records in pages of 20-50 items and load more as the user scrolls:

query.limit = 20
query.skip = page * 20

Use where clauses for server-side filtering. Let Parse filter data before transmission instead of filtering on the client:

query.whereKey("isLiked", equalTo: true)

Summary

This tutorial covered the complete implementation process from setup to working code. You now have a functional implementation that you can extend and customize for your own projects. The same patterns apply to related features in the iOS ecosystem.

Frequently Asked Questions

What is ParseClientConfiguration? ParseClientConfiguration is a class from the open-source Parse iOS SDK, not an Apple framework. You use it to set your app ID, client key and server URL before initializing Parse. Add the SDK with Swift Package Manager or CocoaPods.

What are the prerequisites for this tutorial? You need Xcode installed on a Mac and basic familiarity with Swift programming. No prior experience with the specific framework is required.

All articles