Live Queries

Data That Updates Itself

Subscribe once, receive updates forever. Live Queries push data changes to your app instantly via WebSocket — no polling, no delays, no stale data.

Live Queries
WebSocket Subscriptions
Instant Data Sync
Offline Support

How Live Queries Work

Subscribe to a query. When data changes, you get notified instantly. No polling required.

Clients
WebSocket
Live Query
Database
Live Example
S
A
Y
#general
3 online
Live
Capabilities

Real-Time Patterns

From simple subscriptions to complex collaborative apps — Live Queries power it all.

01Live Queries

Subscribe to Data Changes

Create a query once, receive updates forever. When any object matching your query changes, you get notified instantly via WebSocket.

  • Subscribe with query.subscribe()
  • Same query constraints as regular queries
  • Automatic WebSocket management
  • Works with all Parse data types
  • Filter by any field or relation

Push, not poll.

// Subscribe to changes
const
subscription = await query.subscribe();
subscription.on('create', (obj) => {)
// Instant notification
});
Connected via WebSocket
02Events

React to Every Change

Handle creates, updates, deletes, and even when objects enter or leave your query results. Full control over how your app responds.

  • create — New object matches query
  • update — Existing object modified
  • delete — Object removed
  • enter — Object now matches query
  • leave — Object no longer matches

Every change, captured.

Event Stream
10:23:45createNew message from Alice
10:23:47updateBob edited message
10:23:52enterCarol joined room
03Sync Patterns

Real-Time Architecture

Build collaborative apps where every user sees the same data at the same time. No refresh buttons, no stale data.

  • Multi-user real-time sync
  • Optimistic UI updates
  • Conflict resolution strategies
  • Presence indicators
  • Typing indicators and cursors

Everyone in sync.

Multi-User Sync
A
Alice
In Sync
B
Bob
04Offline First

Works Without Internet

Store data locally, work offline, and sync automatically when connection returns. Real-time meets reliability.

  • Local datastore on device
  • Automatic sync on reconnect
  • Queued mutations while offline
  • Conflict detection
  • Background sync

Online or offline, it works.

Connection Status
Offline
Queued: 3 changes
Back Online
Syncing...
All changes synced
Back4app AI Agent
Set up Live Queries with AI
Set up real-time chat with typing indicators for my Message class
Live Query enabled & code generated:
subscription.on('create', ...)
MCP Protocol Compatible
AI-Powered Development

Set Up Real-Time with AI

Describe the real-time functionality you need, and AI configures Live Queries, generates subscription code, and sets up event handlers for you.

Works with Cursor, VS Code, Windsurf, and more
Enable Live Queries on classes automatically
Generate subscription code from descriptions
Set up event handlers for create/update/delete
Configure offline sync patterns
Code Examples

Real-Time Code Patterns

Copy-paste examples for common real-time use cases.

Subscribe

Live Query

Create a subscription to receive real-time updates

// Subscribe to real-time updates
const query = new Parse.Query('Message');
query.equalTo('chatRoom', roomId);
query.descending('createdAt');

// Create subscription
const subscription = await query.subscribe();

// Handle new messages
subscription.on('create', (message) => {
  console.log('New message:', message.get('text'));
  addMessageToUI(message);
});

// Handle message edits
subscription.on('update', (message) => {
  console.log('Message updated:', message.id);
  updateMessageInUI(message);
});

// Handle deletions
subscription.on('delete', (message) => {
  console.log('Message deleted:', message.id);
  removeMessageFromUI(message);
});

// Clean up when done
// subscription.unsubscribe();
Use Cases

What Can You Build?

Live Queries power real-time experiences across every industry.

Chat & Messaging

Instant message delivery, typing indicators, read receipts, and online status.

Collaboration Tools

Real-time document editing, shared whiteboards, and multiplayer cursors.

Live Dashboards

Real-time analytics, IoT sensor data, and financial tickers that update instantly.

Multiplayer Games

Sync game state, player positions, leaderboards, and match events across players.

Notifications

Push alerts, activity feeds, and system notifications in real-time.

Location Tracking

Real-time maps, delivery tracking, and geo-fenced alerts.

FAQ

Frequently Asked Questions

What are Live Queries?
Live Queries allow clients to subscribe to data changes in real-time. When objects matching your query are created, updated, or deleted, your application receives instant notifications via WebSocket connections. No polling required.
Which platforms support Live Queries?
Live Queries are supported in JavaScript (Web & Node.js), iOS (Swift), Android (Kotlin/Java), and Flutter SDKs. All platforms use WebSocket connections for efficient real-time communication.
Can I filter what changes I receive?
Yes. Live Query subscriptions use the same query constraints as regular queries. Filter by equality, comparisons, containment, geo-queries, and more. You only receive updates for objects matching your criteria.
What events can I subscribe to?
Live Queries support four events: 'create' (new object matches query), 'update' (existing object updated), 'delete' (object deleted), and 'enter'/'leave' (object starts/stops matching query constraints).
How does offline/reconnection work?
SDKs automatically handle WebSocket reconnection. When connection is restored, subscriptions are re-established. Combine with local datastore for offline-first apps that sync when back online.

Build Real-Time Apps Today

Start with Live Queries in minutes. No credit card required.