Parse Developer Community

In 2011, when we launched Parse, we caught the attention of a lot of great mobile developers, eager for a solution like ours. We were quickly faced with questions and feedback that needed to be fielded. We decided to do what many young startups do and built our own tool, a custom Community Forum that was similar to Stack Overflow but tightly integrated with Parse. This has been a labor of love for us, and for a long time, it was precisely the tool that worked well for us.

After 2 years and over 20,000 questions, we’ve decided to try something more scalable and familiar to developers around the world. We will be moving over to several industry standard tools like Stack Overflow and Google Groups to help accommodate the growing community of Parse developers. Whenever we’ve found ourselves in need of help, we’ve gravitated towards using these same tools. We’re excited to continue fostering a vibrant Parse developer community and we hope you’ll take advantage of it when you need help building something awesome. For those of you that have contributed so much time and energy to our community forums in the past, we’d like to enthusiastically say: Thank you!

Plus—don’t forget about the new way to report bugs that we launched earlier this year. This has helped us move from just a couple of folks handling bug reports to a global team of bug squashers, based in London, Dublin, and the US.

We hope you’ll find these new tools helpful, and we invite you to try all of them out on our new Help page.

Héctor Ramos
June 26, 2014

Building Apps with Parse and Swift

On Monday at WWDC 2014, Apple released a new programming language called Swift. As always, when we see that developers are excited about a new language or platform, we work quickly to make sure Parse can support that momentum. We’re excited about Swift because it brings a whole host of new language features to iOS and OS X development. Swift’s type inference will save developers a ton of typing and generics will reduce runtime errors by giving us strongly-typed collections. To learn more about Swift, checkout Apple’s reference book.

One of the best things about Swift for existing iOS developers is that it’s fully compatible with existing Objective-C libraries, including system libraries like Cocoa and third-party libraries like Parse. To start using Parse in your Swift projects:

* Add a new file to your project, an Objective-C .m file.
* When prompted about creating a bridge header file, approve the request.
* Remove the unused .m file you added.
* Add your Objective-C import statements to the created bridge header .h file:

#import <Parse/Parse.h>
// or #import <ParseOSX/ParseOSX.h>

This StackOverflow answer gives a more thorough explanation.

Once you’ve added Parse to your bridge header, you can start using the Parse framework in your Swift project. To help you get started, we’ve added Swift example code to our entire iOS/OSX documentation. For example, this is all you need to do to save an object to Parse:

var gameScore = PFObject(className: "GameScore")
gameScore.setObject(1337, forKey: "score")
gameScore.setObject("Sean Plott", forKey: "playerName")
gameScore.saveInBackgroundWithBlock { 
    (success: Bool!, error: NSError!) -> Void in
    if success {
        NSLog("Object created with id: \(gameScore.objectId)")
    } else {
        NSLog("%@", error)

To then query for the object by its id:

var query = PFQuery(className: "GameScore")
query.getObjectInBackgroundWithId(gameScore.objectId) {
    (scoreAgain: PFObject!, error: NSError!) -> Void in
    if !error {
        NSLog("%@", scoreAgain.objectForKey("playerName") as NSString)
    } else {
        NSLog("%@", error)

That’s everything you need to know to start using Swift with Parse. For more examples, don’t forget to visit our iOS/OSX documentation. We can’t wait to see what you build with it!

Fosco Marotto
June 6, 2014

Parse is Coming to London!

Big Ben in white on a Parse blue backgroundOver the past year, 140,000 new developers started building mobile apps on Parse and 50% of those developers were from Europe, the Middle East, and Africa. With thousands of developers using Parse throughout the UK, we’re building a team in London to better support the area’s thriving developer community and engineering talent.

The Parse London team will be based out of the Facebook London office, which is moving to a beautiful new location in central London in early June. We’re hiring engineers to help build the next big Parse products and to support products we’re building in collaboration with the Facebook Platform team.

We’re also looking for partner managers and partner engineers who will work directly with the biggest app developers in Europe, helping them to build awesome cross-platform apps using Parse. The team is already working with companies like Deezer, TopShop and Mind Candy.

We prioritize our product road map based on the feedback we get from our customers, and having a team on the ground in London allows us to cater the future of Parse products to the needs of our global community.

If you’re in London tonight, join us for a Parse meetup and cocktail party at Facebook to celebrate and meet some of our team. Sign up for the group here; we’d love to meet you!

If you’re interested in working at Parse in London, you can apply here. For job descriptions, please visit the Parse jobs page.

Ilya Sukhar
May 8, 2014

Take Your App Offline with Parse Local Datastore

Parse Local Datastore Banner with tagline: "The power of Parse even when your app isn't connected to a network."

How many times have you opened an app and stared at a loading screen for minutes, only to be confronted with the dreaded, “No internet connection”? Most mobile applications are simply clients that display data straight from a server, losing all functionality without an internet connection. How great would it be, though, if an app worked regardless of bad reception or lack of connectivity?

To make taking your app offline easier, we’re excited to announce Parse Local Datastore.

Parse Local Datastore is a new feature in the Parse Android SDK that lets you to take your app offline with just a few simple lines of code. ParseObject#pin() adds ParseObjects to the Local Datastore and ParseObject#unpin() removes them. Once pinned, you can access them anytime with a normal ParseQuery:

// Pin ParseQuery results
List<ParseObject> objects = query.find(); // Online ParseQuery results

// Query the Local Datastore
ParseQuery<ParseObject> query = ParseQuery.get("Feed")
    .whereEquals("starred", true)
    .findInBackground(new FindCallback() {
        public void done(List<ParseObject> objects, ParseException e) {
            // Update UI

Pinned ParseObjects will remain accessible while offline — through app exits and restarts — until they are unpinned. Subsequent saves, updates, or deletes will keep your Parse Local Datastore results up-to-date.

You can also choose to update your object using ParseObject#saveEventually(). This will first update its instance in the Local Datastore and then remotely, so any changes can be kept up-to-date while offline:

ParseObject feed = ParseQuery.get(objectId); // Online ParseQuery result
feed.put("starred", true);

// No network connectivity

ParseQuery<ParseObject> query = ParseQuery.get("Feed")
	.whereEquals("starred", true)
	.findInBackground(new FindCallback() {
		public void done(List<ParseObject> objects, ParseException e) {
			// "feed" ParseObject will be returned in the list of results

This also means that if you’re already using ParseObject#saveEventually() to protect your app against network failures, you’ll get most of this without any additional work, simply by updating to the latest Android SDK and enabling Local Datastore.

With Parse, it’s easy to take your app offline! Check out our guide and API docs to take your Android app offline now. Stay tuned for iOS, coming soon.

Grantland Chew
April 30, 2014

The More You Grow, the More You Know

Parse Growth Analytics BannerUnderstanding how your app behaves in the wild should be as seamless as possible. Parse Analytics has thus far focused on ease of integration and ease of use. For apps already part of the Parse ecosystem, this is even more true: we can provide value while removing the need to instrument every operation in your app. And now, with Facebook in our corner, we’re able to leverage even greater resources to help you learn about your app’s performance.

Today, we’re pleased to announce the next steps in our journey: the new “Audience” and “Retention” tabs in your Analytics dashboard. After you’ve built your mobile app, the next step is to build, grow, and retain your user base. Loyal users are key to an app’s long-term success, and with these new growth-centric insights, you’ll be able to keep track of your users better than ever before.

How many people are using my app? And how often?

Under the new Audience tab, we expose information about your Daily, Weekly, and Monthly active Users and Installations. While these links are to the iOS version of these docs, Users and Installations are available across all platforms. You’re likely using one or both in your app already!

With these newest additions to your Analytics dashboard, you can see growth week over week per stat, as well as daily over time.


As always, we’ve got your data in multiple formats: compare Daily Active Users to Monthly Active Users, take a look at week-over-week changes to your Daily Active stats, or watch your Weekly Actives trend over time.

Curious how to read these numbers? We’ve brought in our expert analyst, Dev, to chat about how to interpret these charts and what sorts of patterns to keep an eye out for:

Now that I’ve got users, how do I make sure they’re sticking around?

You’ve been able to track your app activity for months, so the natural next step for us was to combine activity data with something more meaningful to you: your users. You can now track retention of your user base — in other words, how many of your users continue to return to your app day after day.

The Retention tab of our new Growth Analytics.

The rows of this table are divided into user cohorts by signup date. As you travel from left to right along a single row, you travel forward in time in that particular cohort’s lifetime: the further right you go, the longer it’s been since the user signed up, and the stickier your app.

The columns of the table, then, each represent “day X since the user signed up.” As you travel down the leftmost column, you’re examining the rate at which users returned 1 day after signup, across cohorts.

While some fluctuation is normal, this Retention tab will provide key insight into when users stop coming back, or which of your features affect your product’s stickiness the most. Take some time to play around with the interface and see what you can learn about your app! Here’s another screencast from Dev with some sample data and handy tips on how to work with this chart:

Coming to an inbox near you: Daily Parse stats for everyone!

At Parse, we’ve been tracking these sorts of metrics ourselves as well: we rely on a daily email, called the Daily Parse, to keep an eye on our audience and retention metrics over time. As a final part of our Growth Analytics offering, we’re bringing this “analytics-in-your-inbox” to all of you.

Starting tomorrow, developers will receive daily updates on how their apps have performed over the last day. There will be information about user signups, installation activations, API requests, and push notifications. You can customize the emails to only include data from certain apps, or opt out of these emails entirely, via your account settings. We hope you’ll find them as useful as we do!

A sample Daily Parse email

Parse is committed to providing robust analytics that emphasize our core strengths: clarity, consistency, and simplicity. We hope you like the new angles we’ve provided into how your app is doing, and as always, let us know what you think! We’ve got more good things to come.

Christine Yen
April 30, 2014

Parse Pricing: Now Cheaper and Simpler!

New Pricing headerI’m really excited to announce a major update to our pricing model that we’ve been working on for some time.

The old model dates back to late 2011 when we first opened up our beta to the world. The overwhelming majority of feedback we got was, “Parse is great but how much is it actually going to cost?” So, we scrambled to put something together quickly, fully expecting to change it before coming out of beta. It turns out that developers loved it and we stuck with it.

We’ve grown an incredible amount over these past three years and it came time to revisit our pricing. We set out to improve it in three ways:

  • Make it easier for developers to predict and estimate their costs when using Parse.
  • Make our product more self-serve for developers who grow very quickly on our platform.
  • Offer more for free!

Moving forward, there won’t be different ‘tiers’ of Parse. There’s only one type of Parse account and you can have an unlimited number of apps or games within it. For each of those apps, you get the following:

  • Parse Core
    • 30 api requests per second (+ $100 per additional 10 reqs/sec)
    • 20GB of file storage (+ $0.03 per GB over)
    • 20GB of database storage
    • 2TB of file transfer (+ $0.10 per GB over)
  • Parse Push
    • 1 million unique recipients/month (+$0.05 per 1,000 unique recipients over)
    • Advanced push targeting, push scheduling, and multiple push certificates available to everyone for free!
  • Parse Analytics
    • Completely free! (including advanced analytics)

New customers will begin using this model today. If you’re an existing customer, you have six months to opt-in. We expect folks to move over quickly as we’re confident that this is a better model for everyone. At 30 requests/sec, an app can send us 77.76 million API requests in a month before needing to pay a dime. That’s over 70X what we offered before!

Thanks for trusting us with your apps. We appreciate your business and are working hard to make sure that Parse is the best way to build great apps across all platforms.

Check out the new pricing page and FAQ for all the details.

Ilya Sukhar
April 30, 2014

Parse Command Line Gets a Power Up

As more people use Cloud Code, we strive to improve the tool that directly supports it, the Parse Command Line Tool. Today, we’re announcing three new features we’ve added to our command line tool: parse updateparse default, and parse jssdk.

parse update

As the name implies, this command helps you update the tool to its latest version. If you’ve previously updated the tool, you had to revisit the Parse docs and copy/paste this script to your terminal:

curl -s | sudo /bin/bash

This is where parse update comes to the rescue! Now, you can update directly from version 1.3.0 or later. This feature is currently only available for Unix-based operating systems, but we’re hard at work getting it added to Windows.

parse default

This command returns the default app that will be targeted with our existing features, such as parse deploy, parse log, parse releases and parse rollback, when an app is not explicitly provided. Before this patch, you had to edit your config file and the _default‘s link to your desired app if you wanted to leverage the default app behavior. Now, you can use parse default [app name] to set your default app.

parse jssdk

This feature returns the current Parse JavaScript SDK used on your Cloud Code. You can also explicitly set your current JavaScript SDK by using parse jssdk [version]. This allows you to have control over the Parse JavaScript SDK on your Cloud Code. You can see all available Parse JavaScript SDK versions by running parse jssdk -a.

$ parse jssdk -a
* 1.2.13

You’ll find the full docs here. Now, go update your command line tool and let us know what you think!

Listiarso Wastuargo
April 9, 2014

A Toast to Windows Phone Users

Did you know that our Push Notifications product supports Windows devices? As developers, we know how important it is to maximize the ability to reach out to your users, regardless of which phone they might be using. For a rapidly growing subset of mobile phone owners, those devices are running Windows, and we wanted to make sure that sending notifications to those users was as easy and powerful as our existing offerings for iOS and Android.

With Windows Phone on our list of supported platforms, you can leverage our API to gain thorough control of when and where you send Windows Toast Notifications. Of course, if you’ve used us for Push before, you know that the simplest method for scheduling notifications has always been through our Push Console – don’t worry, you’ll find an option for Windows Phone there as well.

Windows Phone Push Console

You can configure your Windows Phone app to accept Push Notifications by following the instructions in our Docs. Once you have registered installations of your app, you’ll be able to select the Windows Phone checkbox in the Push Console and see a preview of the Toast Notification that will appear on your users’ devices. Selecting the times and recipients of your notifications is as easy as it always was with the Push Console – the query builder allows you to choose specific subsets of your users, making sure your message gets to exactly the right people.

As always, you can read about all of our Push Notification services in our Docs, including how to track app opens through notifications.

Andrew Imm
April 3, 2014

f8 2014 Schedule Now Available

The schedule for f8 is now available! Mark Zuckerberg will kick it off with a keynote in the morning and then we’ll have more than 20 technical sessions in the afternoon.

We’ll also be live streaming all the keynotes and tracks from f8. If you can’t join us in person, be sure and tune in to the live stream of all the keynotes and tracks to catch all the new stuff and great content. Register here to learn more and be notified when the live stream begins.

Everyone at Parse is really excited to be part of f8 this year and we hope to see you there!

Ashley Smith
April 2, 2014

Production vs Development Apps


It’s a very common use-case to have apps built on Parse that are both still in development and already in production. To help you make a clear distinction between Development Apps and Production Apps, we’re adding a switch in your app’s settings that lets you mark an app as a Production App. This will not only allow you to visually differentiate between your production apps and those still in development mode, but will in the future allow us to add security features that prevent you from accidentally editing content that is in production, or sending test push notifications to actual users (“Whoops!”).

We’re pretty excited about this, and hope you’ll find it useful!

Christophe Tauziet
March 31, 2014