Follow us

Realtime pub/sub engine

Build awesome event-driven user experiences

Kuzzle Backend features a powerful realtime pub/sub query language to build event-driven apps:
data synchronization, chats, push notifications, geofencing, analytics probes, IoT orchestration and more.
Read the documentation to learn more

Case Study

Digital banking: a second screen to photograph, upload documents and sign

Kuzzle's realtime capabilities delivers hand-off multi-screen features, enabling end-users to perform tasks that would otherwise be complex on a regular desktop.
In the video below, the user completes an online subscription tunnel by snapping and instantly uploading a photo, then providing an on-screen signature.
Read the complete case study

Blazing fast pub/sub engine

Developers' corner - SDK(s) examples

Reduce development time and learning curve with Kuzzle SDK(s). They provide high level functions to make developers' life simpler.
Read the documentation to learn more

  • Javascript
  • Android
  • GO
  • /* Subscribe to data changes in an app */

    var kuzzle = new Kuzzle('localhost');

    kuzzle
      .collection('collection', 'index')
      .subscribe({equals: {city: 'nyc'}}, function (error, notification) {
        console.log(notification.document.content.venue);
      })
      .onDone(function (error, room) {
        /* we are now subscribed to the room */
      });
    kuzzle
      .collection('collection', 'index')
      .publishMessage({city: 'nyc', venue: 'MoMa'})
      .publishMessage({city: 'boston', venue: 'TD Garden'})
      .publishMessage({city: 'nyc', venue: 'Madison Square Garden'});
    });

    // output:
    // MoMa
    // Madison Square Garden
  • // Subscribe to data changes in an app
            
            import io.kuzzle.sdk.core.Kuzzle;
            
            Kuzzle kuzzle = new Kuzzle("localhost");
            
            JSONObject filter = new JSONObject().put("exists",
              new JSONObject().put("field", "message"));
            
            kuzzle.collection("mycollection", "myindex")
              .subscribe(filter, new ResponseListener<NotificationResponse>() {
                @Override
                public void onSuccess(NotificationResponse object) {
                  // triggered each time a document is updated !
                  System.out.println("message received from kuzzle:" + object.getResult().toString());
                }
              });
    // Create document
            
            import io.kuzzle.sdk.core.Kuzzle;
            import io.kuzzle.sdk.core.Collection as KuzzleCollection;
            import io.kuzzle.sdk.core.Document as KuzzleDocument;
            
            Kuzzle kuzzle = new Kuzzle("localhost");
            KuzzleCollection collection = kuzzle.collection("mycollection", "myindex");
            KuzzleDocument document = new Document(collection);
            document.setContent("message", "hello world");
            
            collection.createDocument(document);
                      
  • 
            import (
              "fmt"
              "github.com/kuzzleio/sdk-go/collection"
              "github.com/kuzzleio/sdk-go/connection/websocket"
              "github.com/kuzzleio/sdk-go/kuzzle"
              "github.com/kuzzleio/sdk-go/types"
            )
            
            ro := types.NewRoomOptions()
            cn := websocket.NewWebSocket(":7512", o)
            k, _ := kuzzle.NewKuzzle(cn, o)
            c := collection.NewCollection(k, "mycollection", "myindex")
            
            // Subscribing to offers in London and Paris
            type SubscribeFiltersValues struct {
              Values []string `json:"values"`
            }
            type SubscribeFilters struct {
              Cities SubscribeFiltersValues `json:"city"`
            }
            var filters = SubscribeFilters{
              Cities: SubscribeFiltersValues{
                Values: []string{"london", "paris"},
              },
            }
            rtc := make(chan types.KuzzleNotification)
            res := <- c.Subscribe(filters, ro, rtc)
            
            if res.Error != nil {
                fmt.Println(res.Error)
            } else {
              go func (rtc chan types.KuzzleNotification) {
                fmt.Println(<-rtc)
              }(rtc)
            }
            
    
            // Publishing a document matching the subscribe filter
            
            type offerDocument struct {
              City    string `json:"city"`,
              OfferId int    `json:"offerId"`
            }
            
            res, _ := c.PublishMessage(&offerDocument{City: "paris"}, o)
            

They Trust us