Why Realtime?

Many of today’s apps are point-in-time representations of data, refreshing information only when a user explicitly asks for an update. However, interactive apps are infinitely more engaging, updating in realtime as new data becomes available.

All developers need to enhance their traditional request/response data integration by leveraging streaming data to deliver event-driven systems.

Why Reappt?

Reappt is the most intelligent and efficient realtime messaging solution available today. Designed to use a data-centric approach, Reappt provides three critical components to enhance app performance, scale, and stability.


Only binary deltas are sent between two endpoints.

Connection Management

Intelligently manage and optimize each connection.

App Stability

A live data cache provides resilience when systems fail.

Introducing our newest killer feature...

JSON & Binary Delta Streaming

Push Technology’s delta streaming feature provides clients only the differences between old and new data, rather than providing the entire JSON payload – limiting the need to send markup and data that isn’t changing from one message to the next.
Delta streams greatly reduce the bandwidth requirements and latency, offering up to 90% data efficiency improvement.

Realtime Mobile Apps

Traditional integration patterns aren’t always the best choice for mobile.
To improve user experience and performance, you need
efficient realtime data streaming for JSON.

Fast Data for Event Processing & Analytics

Easily collect, format and redistribute data from
multiple sources quickly and easily. Utilize historic and
current data for rich and powerful analytics.

Extend Existing Middleware

Legacy middleware doesn’t work over the Internet.
To support today’s cloud-first integration requirements, you need a network efficient data distribution layer.

Decouple Systems

Applications should not be constrained by backend systems, or be impacted when these systems change. You need a reactive data integration layer that ensures functional decoupling.

Backplane for

A microservices architecture depends on efficient data distribution. You need an event-driven data backplane that performs even when services connect via the Internet.

Optimized Integration
for IoT

IoT represents new challenges of scale for integration architecture. You need intelligent data distribution that removes redundant data and scales to millions of connections.

Consistent and Simple for All Developers

Our modular APIs allow you to choose the features required for each type of client. Whether your clients are publishing, subscribing or both, our Unified API is all you will need.

  • JavaScript / Node
    Publish Data

    session.topics.update('topic', 'Hello World!'); 
    Subscribe to Data

    session.subscribe('topic', function(value) {
    	console.log('Update: ' + value);
  • Java / Android
    Publish Data

    	.update("topic", "Hello World!",
    Subscribe to Data

    public static void main(String... arguments) throws Exception {
    	topics.addTopicStream("topic", new TopicStreamPrintLn());
    		new Topics.CompletionCallback.Default());
    private static class TopicStreamPrintLn extends TopicStream.Default {
        public void onTopicUpdate(String topic, Content content,
                UpdateContext context) {
            System.out.println(topic + ":   " + content.asString());
  • .Net
    Publish Data

    	.Update("topic", "Hello World!", new TopicUpdaterUpdateCallback()); 
    Subscribe to Data

    static void Main( string[] args ) {
    	topics.AddTopicStream("topic", new TopicStreamPrintLn());
    	topics.Subscribe("topic", new TopicsCompletionCallbackDefault());
    private class TopicStreamPrintLn : ITopicStream {
    	public void OnTopicUpdate( string topicPath, IContent content, IUpdateContext context )
    	    Console.WriteLine(topicPath + ":   " + content);
  • C
    Publish Data

    UPDATE_T *upd = update_create(UPDATE_ACTION_REFRESH,
    Subscribe to Data

    char *topic = hash_get(options, "topic");
    subscribe(session, (SUBSCRIPTION_PARAMS_T) { 
    	.topic_selector = topic, 
    	.on_topic_message = on_topic_message, 
    	.on_subscribe = on_subscribe });
    on_topic_message(SESSION_T *session, const TOPIC_MESSAGE_T *msg)
            printf("Received message for topic %s\n", msg->name);
            printf("Payload: %.*s\n", (int)msg->payload->len, msg->payload->data);
            return HANDLER_SUCCESS;
  • Apple (iOS & OS X)
    Subscribe (Swift)

    	completionHandler: {(error: NSError) -> Void in
        if !error {
            NSLog("Subscription Successful.")
        } else {
            NSLog("Failed to Subscribe with Error: %@", error)
    Subscribe (Objective-C)

    [session.topics subscribeWithTopicSelectorExpression:@"topic"
                                       completionHandler:^(NSError * error)
        if (!error) {
            NSLog(@"Subscription Successful.");
        } else {
            NSLog(@"Failed to Subscribe with Error: %@", error);
Background Image

Be the first to know about new features, news and offers.