Support any use case on any device

With Kinvey, you’re free to choose the right tools for your unique projects.

Different projects require different tools. Kinvey’s platform agnostic solution allows developers to focus on what they do best - building great apps.

Client libraries provide a consistent set of features for all of today’s top native, hybrid, and web development frameworks.

Self-service access speeds development – no services required.

Develop apps with the resources that make sense for you – in-house, agency, or systems integrator.

Plug-in client features accelerate development

Your Client Tier adds important mobile features with a single line of code.

Mobile is different than web – it requires an additional layer to maximize performance and engage users.

Important mobile features like offline caching, network management, and more come pre-built in our libraries so your developers don’t have to reinvent the wheel for every app on every platform.

RESTful data access and drop-in features mean your apps get built faster in a consistent and secure manner.

We do the hard work to keep client libraries up to date so you can consume, instead of build, mobile features.

[KCSUser loginWithUsername:@"kinvey" password:@"12345" withCompletionBlock:^(KCSUser *user, NSError *errorOrNil, KCSUserActionResult result) {
  if (errorOrNil ==  nil) {
    //the log-in was successful and the user is now the active user and credentials saved
    //hide log-in view and show main app content
  } else {        
   	//there was an error with the update save
    NSString* message = [errorOrNil localizedDescription];
    UIAlertView* alert = [[UIAlertView alloc] initWithTitle:NSLocalizedString(@"Create account failed", 
    @"Sign account failed")
          cancelButtonTitle:NSLocalizedString(@"OK", @"OK")
            otherButtonTitles: nil];
              [alert show];
KCSCollection* collection = [KCSCollection collectionFromString:@"ACollection" ofClass:[DataClass class]];
KCSCachedStore* store = [KCSCachedStore storeWithCollection:collection
    options:@{KCSStoreKeyCachePolicy : @(KCSCachePolicyNetworkFirst)}];
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
    //Your App Setup...
    (void) [[KCSClient sharedClient] initializeKinveyServiceForAppKey:@"<#My App Key#>"
      withAppSecret:@"<#My App Secret#>" 
    //Start push service
    [KCSPush registerForPush];
    return YES;
[_mapStore queryWithQuery:tagQuery withCompletionBlock:^(NSArray *objectsOrNil, NSError *errorOrNil) {
    [self.activityIndicator stopAnimating];
    if (errorOrNil == nil) {
        // Add all the returned annotations to the map
        [self.worldView addAnnotations:objectsOrNil];
NSDictionary* options = @{KCS_DATA_PROTECTION_LEVEL : @(KCSDataComplete)};
KCSReachability* kinveyReachability = [KCSClient sharedClient].kinveyReachability;
BOOL isWifi = kinveyReachability.isReachableViaWiFi;
BOOL isCellular = kinveyReachability.isReachableViaWWAN;
public void submit(View view) {
  mKinveyClient.user().login(new KinveyUserCallback() {
    public void onFailure(Throwable t) {
      CharSequence text = "Login error.";
      Toast.makeText(getApplicationContext(), text, Toast.LENGTH_SHORT).show();
      public void onSuccess(User u) {
        CharSequence text = "Welcome back!";
        Toast.makeText(getApplicationContext(), text, Toast.LENGTH_SHORT).show();
        LoginActivity.this.startActivity(new Intent(LoginActivity.this, 
AsyncAppData ad = mKinveyClient.appData("myCollection", MyEntity.class);
ad.setOffline(OfflinePolicy.LOCAL_FIRST, new SqlLiteOfflineStore(getContext()));
public class GCMService extends KinveyGCMService {
  public void onMessage(String message) {
    public void onError(String error) {
    public void onDelete(String deleted) {
    public void onRegistered(String gcmID) {
    public void onUnregistered(String oldID) {
  //This method will return the WakefulBroadcastReceiver class you define in the next step
  public Class getReceiver() {
      return GCMReceiver.class;
  private void displayNotification(String message){
    NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this)
      NotificationManager mNotificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
[_mapStore queryWithQuery:tagQuery withCompletionBlock:^(NSArray *objectsOrNil, NSError *errorOrNil) {
    [self.activityIndicator stopAnimating];
    if (errorOrNil == nil) {
        // Add all the returned annotations to the map
        [self.worldView addAnnotations:objectsOrNil];
myAppData.setOffline(OfflinePolicy.LOCAL_FIRST, new SecureOfflineStore(getApplicationContext()));

 var promise = Kinvey.User.signup({
  username : 'username',
  password : 'password'
}, {
  success: function(response) {
  appKey    : 'App Key',
  appSecret : 'App Secret',
  sync      : {
    enable : true,
    online : navigator.onLine
    // The initial application state.
// Switch application state when the on- and offline events fire.
  offline : Kinvey.Sync.offline,
  online  :
// Method to register device with Kinvey.
var registrationHandler = function(deviceId) {
  if(null === Kinvey.getActiveUser()) {
      // Error: there must be a logged-in user.
  else {
      Kinvey.Push.register(deviceId).then(function() {
          // Successfully registered device with Kinvey.
      }, function(error) {
          // Error registering device with Kinvey.
  _id: 'entity-id',
  _geoloc: [ -71, 42 ]// longitude: -71, latitude: 42.
document.addEventListener('deviceready', function() {
  // Prompt the user for its encryption key.
  navigator.notification.prompt('Please enter your encryption key.', function(results) {
      var encryptionKey = results.input1;
      // Initialize Kinvey with the specified `encryptionKey`.
      var promise = Kinvey.init({
        appKey        : 'App Key',
        appSecret     : 'App Secret',
          encryptionKey : encryptionKey
      }).then(function(activeUser) {
      }, function(error) {
  }, 'Data Encryption', ['OK']);

mKinveyClient.user().Login(username, password, new KinveyDelegate() {
  onSuccess = (user) => {
    //user logged in
  onError = (error) => {
    //`error` contains information about the error that occured.
AppData entityCollection = kinveyClient.AppData(myCollectionName, typeof(MyEntity));
entityCollection.setOffline(new SQLiteOfflineStore(), OfflinePolicy.LOCAL_FIRST);
 using KinveyXamarinAndroid;
public class GCMService : KinveyGCMService {
  public override void onMessage(String message) {
  public override void onError(String error) {
  public override void onDelete(int deleted) {
  public override void onRegistered(String gcmID) {
  public override void onUnregistered(String oldID) {
  private void displayNotification(String message){
// Find all entities within a sphere centered at latutude 41, Longitude -71
string query1 = "{\"_geoloc\":{\"$nearSphere\":[-71,41]}}"
myAppData.setOffline(new SecureOfflineStore(this.ApplicationContext), OfflinePolicy.LOCAL_FIRST);  

  • User

  • Offline

  • Push

  • Location

  • Data

Turn-key backend services support new mobile use cases

Access data, identity, engagement, and business logic services with a single API using your Mobile Context Tier.


Data &

  • Enterprise integration microservices

    (Data links for SQL, SOAP, and others)

  • SaaS integrations
  • Data & file store
    • CDN
    • REST

Identity &
Access Mgmt

  • Mobile Identity Connect enterprise connectors

    (LDAP, SAML & Active Directory)

  • 3rd party OAuth

    (Google, Facebook, Twitter, Salesforce, etc.)

  • Kinvey built-in OAuth2

Engagement &

  • Analytics
  • Push notifications
  • Location
  • Beacons
    • Email
    • SMS
Business logic

Business Logic & Orchestration

  • Mobile PaaS
  • Triggers
  • Data mashups
  • Validation

Mobile apps require new features that your enterprise can’t support today. Instead of building and maintaining them for each app, deliver a standardized and consistent platform for all your development needs.

Microservices securely integrate your enterprise systems

Your Mobile Aggregation Tier delivers flexibility for your business lines and consistency and compliance for IT.

Transformative apps combine data from multiple sources with new mobile capabilities. But you have to provide consistent and secure access.

Let IT maintain control over the connections to your enterprise systems. No more building integrations for each app – build once and reuse them via data and identity microservices.

Implement the connectors where they make sense to your business – either in the cloud or behind your enterprise firewall.

Your data is encrypted at rest and in transit for consistent, end‑to‑end security.

Security at every layer of the stack

Kinvey makes it easy to build highly secure, IT-compliant applications.

Security is a top priority for enterprise IT. We understand, and we built Kinvey to be highly secure at every layer.

Our libraries ensure data on the client is automatically encrypted at rest and in motion, while our service ensures security in the cloud and to the data center.

We continuously monitor our services, perform regular data backups, and have an independent vendor perform penetration testing regularly.

Operational Intelligence gives IT support actionable insights for fast problem resolution

Most mobile app analytics products service the needs of marketers and product managers. Kinvey Operational Intelligence helps IT operations and support teams to:

  • Quickly troubleshoot and resolve end user issues using standard and customizable dashboards
  • Monitor and report on compliance events by creating sophisticated filters and correlations for individual apps and users
  • Identify performance bottlenecks and high-latency queries against legacy enterprise IT systems

Operational Intelligence for IT support has been the forgotten aspect of mobile analytics. Not any more.

premium analytics

Digital lifecycle management

App team collaboration and backend environment versioning.

Team collaboration

  • Supports distributed development and use of partners or systems integrators.
  • Admins control who has access to different development, staging, and production environments.
  • Enables 2 speed IT with loosely coupled frontend and backend teams.

Environment versioning

  • Create multiple versions of an app backend with a single command.
  • Easily migrate changes from one environment to another.
  • Developers can continuously innovate without impacting production.

Fully managed with your choice of deployment models

Don’t deal with infrastructure, operations, and keeping pace with changes in mobile technology. Use a self-service cloud platform.

Kinvey scales to any size – a backend for your app or a platform for your enterprise.

  • Global deployments with CDN
  • End-to-end security
  • Compliance reporting
  • Proven at scale
  • Multi-tenant or dedicated
  • Up to date

See what Kinvey can do for your business

Save with the very first app.

Tour our platform services.

Have questions?