Storyly

Overview

Storyly provides a platform and SDKs for embedding interactive story feeds directly into mobile applications. The system is designed to allow mobile app developers to integrate story functionality, similar to formats found on social media platforms, into their own applications. This enables app publishers to create and manage full-screen, vertical content that users can tap through. Storyly supports integration into native iOS and Android applications, as well as cross-platform frameworks including React Native, Flutter, and Unity, broadening its applicability across the mobile development ecosystem.

The core use case for Storyly involves enhancing user engagement and retention. By delivering dynamic content, apps can guide users through onboarding processes, announce new features, showcase products, or provide interactive tutorials. The platform includes a content management system, Storyly Studio, which allows non-technical users to create, schedule, and publish stories without requiring app store updates. This separation of content creation from development cycles can streamline content delivery and iteration.

For developers, Storyly offers a set of SDKs with documented APIs for integration and customization. The SDKs handle the rendering and playback of stories, while developers can configure the appearance and behavior to match their application's design system. Storyly also provides analytics capabilities to track user interactions with story content, such as views, taps, and completion rates. This data can be used to inform content strategy and optimize engagement. The platform is designed to be compliant with data privacy regulations such as GDPR, addressing a common concern for mobile app publishers.

Storyly is particularly suited for applications that benefit from rich, interactive content to drive user actions or communicate information in an engaging format. This includes e-commerce apps for product discovery, media apps for content highlights, and utility apps for feature explanations. The ability to segment audiences and target specific user groups with relevant story content further refines the potential for personalized in-app experiences.

Key features

• In-App Stories: Embed full-screen, tap-through story feeds within mobile applications, providing a familiar and engaging content format (Storyly documentation on in-app stories).
• Interactive Components: Integrate interactive elements such as polls, quizzes, sliders, and product tags directly into stories to increase user participation and data collection.
• Storyly Studio: A web-based content management system for creating, scheduling, and publishing story content without requiring app updates. This enables content teams to manage campaigns independently.
• Audience Segmentation & Targeting: Deliver personalized story content to specific user segments based on demographics, behavior, or other custom attributes.
• Analytics & Reporting: Track key metrics related to story performance, including views, impressions, taps, and completion rates, to optimize content strategy.
• Customization Options: Configure the appearance and behavior of story components to align with the application's branding and user interface guidelines.
• SDKs for Multiple Platforms: Provides native SDKs for iOS (SwiftUI, UIKit) and Android (Kotlin, Java), as well as wrappers for cross-platform frameworks like React Native, Flutter, and Unity.
• GDPR Compliance: Designed with data privacy regulations in mind, including support for GDPR compliance (Storyly homepage).

Pricing

Storyly offers a tiered pricing model that includes a free developer plan and paid plans based on usage and feature sets. Pricing is subject to change; developers should consult the official pricing page for the most current information.

For detailed pricing and current offerings, refer to the official Storyly pricing page.

Common integrations

• iOS applications: Integrate directly into native iOS apps using Swift or Objective-C. The Storyly iOS integration guide provides steps for setup.
• Android applications: Implement Storyly within native Android projects using Kotlin or Java. The Storyly Android integration guide details the process.
• React Native: Utilize the Storyly React Native SDK to add stories to cross-platform React Native projects. Refer to the Storyly React Native integration documentation.
• Flutter: Integrate Storyly into Flutter applications using the Flutter plugin. The Storyly Flutter integration guide covers installation and usage.
• Unity: For games and interactive experiences built with Unity, Storyly offers an SDK to embed story content. The Storyly Unity integration documentation provides specific instructions.
• Firebase: Storyly can be integrated with Firebase for user authentication and analytics, allowing for segmented content delivery based on Firebase user data (Firebase documentation).
• Analytics Platforms: While Storyly provides its own analytics, data can often be piped into broader analytics platforms for a unified view of user behavior.

Alternatives

• Appcues: Focuses on user onboarding, product tours, and announcements with a no-code builder.
• Userflow: Provides in-app guides, checklists, and surveys for user onboarding and feature adoption.
• Intercom: Offers a suite of tools for customer messaging, support, and engagement, including in-app messages and product tours.

Getting started

To integrate Storyly into an Android application using Kotlin, you would typically add the Storyly SDK to your build.gradle file, initialize it in your application, and then add a Storyly view to your layout. The following example demonstrates a basic integration:

// build.gradle (app-level)
dependencies {
    implementation 'com.storyly:storyly-android:1.x.x' // Check Storyly docs for latest version
}

// MainActivity.kt
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import com.storyly.StorylyView
import com.storyly.StorylyInit

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val storylyView = findViewById<StorylyView>(R.id.storyly_view)
        // Replace "YOUR_STORYLY_INSTANCE_TOKEN" with your actual token from Storyly Studio
        storylyView.storylyInit = StorylyInit("YOUR_STORYLY_INSTANCE_TOKEN")
    }
}

// activity_main.xml (layout file)
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <com.storyly.StorylyView
        android:id="@+id/storyly_view"
        android:layout_width="0dp"
        android:layout_height="120dp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:storyly_orientation="horizontal"
        app:storyly_layout_direction="ltr" />

</androidx.constraintlayout.widget.ConstraintLayout>

This code snippet initializes the StorylyView in an Android activity after adding the SDK dependency. The StorylyInit object requires an instance token, which is obtained from the Storyly Studio dashboard. The StorylyView is then placed within the activity's layout XML, where its dimensions and orientation can be configured. Further customization and event handling can be implemented by referring to the Storyly Android SDK documentation.