Create GraphQL APIs on Elasticsearch in 2 minutes

Connect Hasura to your new or existing Elasticsearch NoSQL database and generate high-quality, secure, and performant GraphQL APIs.

Instant GraphQL APIs

Build high-quality GraphQL APIs on Elasticsearch, instantly

Connect to a new or existing Elasticsearch NoSQL database and get standardized, highly composable GraphQL APIs. The Hasura GraphQL Engine introspects the database and automatically generates GraphQL schemas and resolvers based on the Elasticsearch index and documents.

GraphQL queries on Elasticsearch

Leverage the full power of GraphQL API to interact with your Elasticsearch database for all your read use cases.

Query exactly what you want from your Elasticsearch index and documents.

Relationships and nesting

The GraphQL API on Elasticsearch handles relationships between indices and queries can be nested to any depth if required.

Pagination

Easily manage large datasets with built-in pagination capabilities. Cursor-based, Relay-style, and offset-based pagination is supported natively.

Filtering

Filter query results on Elasticsearch documents and fields using advanced WHERE clauses and Boolean / logical operators like _and / _or, etc.

Sorting

Sort data based on multiple fields in Elasticsearch documents and specify the sort direction (ascending or descending), making it easy to present your data.

Aggregation (coming soon)

Perform various aggregations to get detailed statistics about your Elasticsearch data directly within your GraphQL queries. Leverage aggregate functions in Elasticsearch like count, sum, min, max, avg, etc.

Vector search

Perform similarity, nearest neighbor vector search using native queries.

query fetchAccountsAndCustomer {
  accounts(where: { account_id: { _eq: "AZ2376" } }) {
    id
    account_id
    name
    customer {
      id
      first_name 
      last_name
      zip_code
    }
  }
}

Fetch accounts' data like the `id` and `name` where the account_id is equal to some value, and fetch the `customer` data for the account.

query {
 authors(where: { "range": {
            "age": {
                "gte": 20,
                "lte": 45
            }
        }}) {
   id
   name
   age
 }
}

Fetch a list of authors who have articles with a rating greater than 4 along with those articles which have a rating greater than 3.

query {
  articles_aggregate {
    aggregate {
      count
      sum {
        rating
      }
      avg {
        rating
      }
      max {
        rating
      }
    }
    nodes {
      id
      title
      rating
    }
  }
}

Fetch a list of articles with aggregated data of their rating.

query MyQuery {
 moviesSearch(
   ninGenres: ["Drama", "Western", "Crime"]
   inGenres: ["Action", "Adventure", "Family"]
   gteYear: 1960
   lteYear: 2000
   numCandidates: 200
   limit: 2
 ) {
   genres
   plot
   score
   year
   title
 }
}

Search movies based on vector.

GraphQL mutations on Elasticsearch

Perform robust data manipulation operations on your Elasticsearch database with GraphQL mutations. Insert, update, or delete data in Elasticsearch via Hasura’s native mutations. (*coming soon)

mutation {
 insert_artist(id: 100, name: "New Artist") {
   ArtistId
   Name
 }
}

Insert into the artist document in Elasticsearch index with values for `id` and `name` fields.

High-performance GraphQL APIs, at scale

Hasura takes a domain-driven approach to GraphQL, where a GraphQL query is compiled to a query on a domain model (a database query or existing APIs) resulting in superior API performance.

Hasura leverages the goodness of Elasticsearch to create efficient GraphQL queries.

Compile vs. resolve

Hasura avoids the GraphQL N+1 query problem by compiling a query instead of resolving. This compiler-based approach allows Hasura to form a single database query for a GraphQL query of any depth and avoids the N+1 problem in GraphQL.

Predicate pushdown database query Elasticsearch

Hasura filters data at the source with a predicate pushdown of queries to Elasticsearch. Hasura can push down a majority of queries like projection, permissions, arguments, and filtering.

Performance benchmarks

Hasura’s GraphQL APIs are faster than handwritten subgraphs on top of Elasticsearch

Learn more about how Hasura does high-performance domain-driven APIs.

Add caching to existing Elasticsearch APIs for faster response times

Get up to 10x faster API performance on Elasticsearch with end-to-end caching, scaling vertically and horizontally.

Hasura has metadata about the data models across data sources, and the authorization rules at the application level, which helps provide end-to-end caching.