Create GraphQL APIs on Timescale in 2 minutes

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

Instant GraphQL APIs

Build high-quality GraphQL APIs on Timescale, instantly

Connect to a new or existing Timescale 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 Timescale hypertables, views, and functions.

GraphQL queries on Timescale

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

Query exactly what you want from your Timescale hypertables, views, and functions.

Relationships and nesting

The GraphQL API on Timescale handles relationships between models, 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 Timescale using advanced WHERE clauses and Boolean / logical operators like _and / _or, etc.

Sorting

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

Aggregation

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

Vector search

Perform similarity / vector search using native queries.

query {
  last_fifteen_mins_stats {       
    fifteen_min,    
    max_temp,    
    max_hum,
    location {
      id
      name
    }
  }
}

Querying timeseries data with `timebucket` underneath the view and fetching relational information from another table called location.

query {
  last_fifteen_mins_stats(where: {max_temp: {_gt: 10}}) {       
    fifteen_min,    
    max_temp,    
    max_hum
    location
  }
}

Fetch last fifteen min stats where the maximum temperature is greater than 10.

query {
  last_fifteen_mins_stats(order_by: {max_temp: desc}) {       
    fifteen_min,    
    max_temp,    
    max_hum
    location
  }
}

Fetch last fifteen min stats, ordered by descending temperature.

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 {
  productsVectorDistance(
    args: {query_vector: "<input vector>"}
    limit: 10
    order_by: {
      distance: Asc
    }
    where: {
      product: {
        price: {
          _gt: 500
        }
      }
    }
  ) {
    id
    distance
    product {
      name
    }
  }
}

Search products based on vector and price.

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 Timescale and PostgreSQL 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 SQL query for a GraphQL query of any depth and avoids the N+1 problem in GraphQL.

JSON aggregations in Timescale

Hasura avoids the Cartesian product problem while fetching data from the underlying system by performing JSON aggregations in Timescale.

Predicate pushdown SQL to Timescale

Hasura filters data at the source with a predicate pushdown of SQL queries to Timescale.

Performance benchmarks

Hasura’s GraphQL APIs are 3x faster than handwritten subgraphs on top of PostgreSQL

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

Scaling Timescale with read replicas

Maximize your Timescale database performance and scalability with Hasura’s read replicas support.

Easily configure Timescale/PostgreSQL read replicas in Hasura to offload read-intensive operations, achieve seamless load balancing, and perform real-time analytics without impacting your primary database.

Configure routing, connection pooling, and load balancing.

Add caching to existing Timescale APIs for faster response times

Get up to 10x faster API performance on Timescale 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.

Production-ready APIs on Timescale, from day one

Observability

Monitor for known issues by debugging and analyzing metrics from your Hasura instance.

API security

Secure your Timescale APIs with tools including allow list, multiple JWT secrets, API rate limits, and more.

Authorization

Make granular read and write access control easy to configure on your Timescale database with a built-in authorization engine.

Works with PostgreSQL flavors

Works with PostgreSQL flavors of your choice

Hasura is fully compatible with PostgreSQL standards. Choose the optimal PostgreSQL flavor for your use case. Use TimescaleDB for efficient time-series data handling and switch to vanilla PostgreSQL for other transactional workloads.