     /// Run multiple queries on this index.
     ///
     /// - parameter queries: The queries to run.
+    /// - parameter strategy: The strategy to use.
     /// - parameter completionHandler: Completion handler to be notified of the request's outcome.
     /// - returns: A cancellable operation.
     ///
     @objc public func multipleQueries(queries: [Query], strategy: String?, completionHandler: CompletionHandler) -> NSOperation {
-        let emulator = MultipleQueryEmulator(indexName: self.name, querier: { (query: Query) in
-            let searchResults = self.localIndex.search(query.build())
-            return OfflineClient.parseSearchResults(searchResults)
-        })
-        let operation = NSBlockOperation() {
-            let (content, error) = emulator.multipleQueries(queries, strategy: strategy)
+        let operation = NSBlockOperation() {
+            let (content, error) = self.multipleQueriesSync(queries, strategy: strategy)
             self.callCompletionHandler(completionHandler, content: content, error: error)
         }
         client.searchQueue.addOperation(operation)
         return operation
     }
-    
-    /// Run multiple queries on this index.
+
+    /// Run multiple queries on this index (synchronous version).
     ///
     /// - parameter queries: The queries to run.
     /// - parameter strategy: The strategy to use.
+    /// - returns: A mutually exclusive (content, error) pair.
+    ///
+    private func multipleQueriesSync(queries: [Query], strategy: String?) -> APIResponse {
+        let emulator = MultipleQueryEmulator(indexName: self.name, querier: { (query: Query) in
+            return self.searchSync(query)
+        })
+        return emulator.multipleQueries(queries, strategy: strategy)
+    }
+
+    /// Run multiple queries on this index.
+    ///
+    /// - parameter queries: The queries to run.
+    /// - parameter strategy: The strategy to use.
     /// - parameter completionHandler: Completion handler to be notified of the request's outcome.
     /// - returns: A cancellable operation.
     ///
     public func multipleQueries(queries: [Query], strategy: Client.MultipleQueriesStrategy? = nil, completionHandler: CompletionHandler) -> NSOperation {
         return self.multipleQueries(queries, strategy: strategy?.rawValue, completionHandler: completionHandler)
     }
-    
+
+    /// Run multiple queries on this index (synchronous version).
+    ///
+    /// - parameter queries: The queries to run.
+    /// - parameter strategy: The strategy to use.
+    /// - returns: A mutually exclusive (content, error) pair.
+    ///
+    private func multipleQueriesSync(queries: [Query], strategy: Client.MultipleQueriesStrategy? = nil) -> APIResponse {
+        return self.multipleQueriesSync(queries, strategy: strategy?.rawValue)
+    }
+
     // MARK: - Utils
     
     /// Call a completion handler on the main queue.

    ///
    @objc public func getObjects(objectIDs: [String], completionHandler: CompletionHandler) -> NSOperation {
        let operation = NSBlockOperation() {
            var content: [String: AnyObject]?
            var error: NSError?
            let searchResults = self.localIndex.getObjects(objectIDs, parameters: nil)
            (content, error) = OfflineClient.parseSearchResults(searchResults)
            self.callCompletionHandler(completionHandler, content: content, error: error)
        }
        client.searchQueue.addOperation(operation)
        return operation
    }
    
    /// Update an object.

    ///
    @objc public func browseFrom(cursor: String, completionHandler: CompletionHandler) -> NSOperation {
        let operation = NSBlockOperation() {
            let (content, error) = self.browseFromSync(cursor)
            self.callCompletionHandler(completionHandler, content: content, error: error)
        }
        client.searchQueue.addOperation(operation)
        return operation
    }

    /// Browse the index from a cursor (synchronous version).
    /// This method should be called after an initial call to `browse()`. It returns a cursor, unless the end of the
    /// index has been reached.
    ///
    /// - parameter cursor: The cursor of the next page to retrieve
    /// - parameter completionHandler: Completion handler to be notified of the request's outcome.
    /// - returns: A cancellable operation.
    ///
    private func browseFromSync(cursor: String) -> APIResponse {
        let searchResults = self.localIndex.browse(Query(parameters: ["cursor": cursor]).build())
        return OfflineClient.parseSearchResults(searchResults)
    }

    // MARK: - Helpers
    
    /// Delete all objects matching a query (helper).
