Looking for Cloud Services or Professional Support? Check restheart.com


The most effective microservices framework
with REST, GraphQL and WebSocket APIs for MongoDB and Declarative Security.

Download Read the Docs Try Online

Featured on AWS Blog

RESTHeart API for MongoDB simplifies development and frees you to focus on delivering great user experiences


RESTHeart Features

The MongoDB best friend

RESTHeart unlocks all the features of MongoDB via REST, GraphQL and WebSocket APIs.

Also supports Mongo Atlas, AWS DocumentDB, and Azure Cosmos DB

Container friendly

RESTHeart is available as a Docker image and tailored for the GraalVM to build lightweight native images with instant startup time, low memory footprint.

Docker Pulls
Declarative Access Control

RESTHeart provides a powerful and battle-tested security layer that keeps your application secure without coding.

Pleasant Development Framework

Service, Provider, Interceptor and Initializer are the simple yet powerful building blocks to develop microservices in Java, Kotlin, JavaScript or TypeScript.

Developers can focus on coding the microservice logic taking for granted the complex and costly tasks. The Framework ensures the effective management of the runtime process, security, concurrency, HTTP transport protocol, requests routing, logging, configuration and security.

The RESTHeart runtime solves the colored function problem: leveraging a scalable and pooled thread-per-request concurrency model, developers don't need to cope with complex asynchronous programming (and this applies too JavaScript as well)!


Read, write and search JSON documents with HTTP requests without coding; specify MongoDB queries and projection options; deal with large result sets with automatic pagination.

GraphQL Data API

The GraphQL plugin works side by side with the REST plugin to get an unified API to build modern applications. GraphQL applications are configured through an API without coding.

WebSocket Data API

The WebSocket API notifies clients of data changes in real time and supports thousands of connected clients. Data streams are configured through an API without coding.

The Data API

Query documents from the command line with httpie.

The GET request has two query parameters: filter to apply a query and pagesize to limit the response to one document.
Here we use the brilliant httpie, a modern command line HTTP client.

More examples
$ http -b GET https://demo.restheart.org/messages'?filter={"from":"Bob"}&pagesize=1'

        "_id": {
            "$oid": "5c50963e477870eb8258fa68"
        "from": "Bob",
        "message": "was here"

Query documents from the command line with cURL.

The GET request has two query parameters: filter to apply a query (that needs to be encoded with --data-urlencode option since it contains the curly brackets) and pagesize to limit the response to one document.
Here we use the immortal cURL!

More examples
$ curl -G --data-urlencode 'filter={"from":"Bob"}' https://demo.restheart.org/messages?pagesize=1

        "_id": {
            "$oid": "5c50963e477870eb8258fa68"
        "from": "Bob",
        "message": "was here",

Query documents with JavaScript.

The GET request has two query parameters: filter to apply a query and pagesize to limit the response to one document.
Here we use the fetch API.

Run it
const url = encodeURI('https://demo.restheart.org/messages?filter={"from":"Bob"}&pagesize=1');

  .then(response => response.json())
  .then(json => JSON.stringify(json, null, 2))
  .then(docs => console.log(docs));

Query documents with Java.

The GET request has two query parameters: filter to apply a query and pagesize to limit the response to one document.
Here we use the unirest java http library.

More examples
public void printOutMessages() throws UnirestException {
    var resp = Unirest.get("https://demo.restheart.org/messages")
            .queryString("filter", "{'from':'Bob'}")
            .queryString("pagesize", "1")

    // print out each message
    resp.getBody().getArray().forEach(msg -> System.out.println(msg.toString()));

Query documents with Swift.

The GET request has two query parameters: filter to appy a query and pagesize to limit the response to one document.
Here we use the JSONSerialization to parse the response body.

More examples
import UIKit
import PlaygroundSupport

var urlComponents = URLComponents(string: "https://demo.restheart.org/messages")

// set the query parameters
var queryItems = [URLQueryItem]()
queryItems.append(URLQueryItem(name: "pagesize", value: "1"))
queryItems.append(URLQueryItem(name: "filter", value: "{\"from\":\"Bob\"}"))
urlComponents?.queryItems = queryItems

var urlRequest = URLRequest(url: (urlComponents?.url)!)

// set request method
urlRequest.httpMethod = "GET"

URLSession.shared.dataTask(with: urlRequest) { (data, response, error) in
    guard let dataResponse = data, error == nil
    else {
        print(error?.localizedDescription ?? "Response Error")

    do {
        let jsonResponse = try JSONSerialization.jsonObject(with: dataResponse, options: [])
    } catch let jsonError {

// only needed in playground
PlaygroundPage.current.needsIndefiniteExecution = true

Example Code

Implement web services in minutes.

Implement a simple interface and deploy the web service by copying its jar file into the plugins directory.

See it on GitHub More examples
@RegisterPlugin(name = "greetings", description = "just another Hello World")
public class GreeterService implements JsonService {
    public void handle(JsonRequest req, JsonResponse res) {
        switch(req.getMethod()) {
            case GET -> res.setContent(object().put("message", "Hello World!"));
            case OPTIONS -> handleOptions(req);
            default -> res.setStatusCode(HttpStatus.SC_METHOD_NOT_ALLOWED);

Implement plugins in Kotlin.

You can use Java and Kotlin to implement plugins.

Kotlin Service example
@RegisterPlugin(name = "kotlinGreeterService", description = "just another Hello World in Kotlin")
class GreeterService : JsonService {
    override fun handle(req: JsonRequest, res: JsonResponse) {
        when(req.method) {
            METHOD.GET -> res.content = obj().put("msg", "Hello World").get()
            METHOD.OPTIONS -> handleOptions(req);
            else -> res.setStatusCode(HttpStatus.SC_METHOD_NOT_ALLOWED);

Snoop and modify requests at different stages of their lifecycle.

This interceptor applies to requests of the hello web service adding a timestamp to the response content.
Interceptor can be executed at different points of the request as defined by the interceptPoint parameter of the annotation RegisterPlugin

More examples
@RegisterPlugin(name = "helloInterceptor",
    description = "add a timestamp to the response of /greetings",
    interceptPoint = InterceptPoint.RESPONSE)
public class HelloInterceptor implements JsonInterceptor {
    public void handle(JsonRequest req, JsonResponse res) {
            .addProperty("timestamp", Instant.now().toString());

    public boolean resolve(JsonRequest req, JsonResponse res) {
        return req.isHandledBy("greetings");

Implement plugins in JavaScript.

This is yet another Hello World web service.
Running RESTHeart on the GraalVM allows you to deploy JavaScript Services and Interceptors.

More examples
export const options = {
    name: "helloWorldService",
    description: "just another Hello World",
    uri: "/hello"

export function handle(req, res) {
    res.setContent(JSON.stringify({ msg: 'Hello World' }));

Widely Adopted

RESTHeart Docker image's pulls

Become a sponsor

You can support the development of RESTHeart via GitHub Sponsor program and receive public acknowledgment of your help.

Go and see available sponsor tiers