Hasura

Hasura

Hasura · Coding

Hasura is a metadata-driven supergraph platform that connects your databases, code and APIs and serves them as fast, secure GraphQL endpoints.

Interface preview of Hasura

About Hasura

What Is Hasura

Hasura is a data access layer that sits between your data sources and your applications. You point its connectors at databases, microservices and third-party APIs, define how the data relates in metadata, and Hasura compiles that into a single GraphQL API. Its current flagship is the Hasura Data Delivery Network (DDN), a supergraph that federates many data sources into one endpoint. The company also builds PromptQL, an AI layer for querying that data in natural language, and it maintains the open-source Hasura GraphQL Engine that started the project.

The usual workflow fits teams that keep data in Postgres, MySQL, SQL Server, Snowflake, BigQuery or Oracle and want an API without writing resolvers for each table. Hasura handles filters, pagination, sorting, aggregations and authorization on top of those sources, and you add relationships in metadata rather than code. That opens up a few things you can't do by hand as easily. Field-level and entity-level permissions run inside the engine, so access rules stay in one place. The API also speaks Relay for connection-based clients and supports API versioning and hashed builds for safe schema changes.

There are costs to weigh. DDN runs as a managed cloud product, and using it well means learning its metadata model and CLI, which is a real step up from a plain SQL client. Pricing counts active models, not seats, so a large schema with many frequently queried models can run up a bill. The Rust-based engine is fast, but the learning curve and the managed-only deployment for DDN are the main trade-offs.

Getting Started

  1. Create a free Hasura Cloud account and open the console
  2. Install the DDN CLI and Docker, then initialize a supergraph with ddn supergraph init
  3. Add data connectors for each source, such as a Postgres database or a REST API
  4. Model your data in metadata, define relationships and permissions, then deploy and call the generated GraphQL endpoint

Product Information

A quick look at Hasura's pricing, supported platforms, and performance.

Free PlanYes
Paid Plans$0 - $30/active model/mo
PlatformWeb, Cloud, self-hosted, CLI, Docker
DeveloperHasura
CategoryCoding
Release DateSep 2024
Latest UpdatedSep 2026
Website Visits99.3K
Website Global Rank388.5K
API AvailabilityYes

Best for

The users, tasks, and scenarios where this tool fits best.

Users

  • Backend and full-stack developers
  • Platform engineering teams
  • Data teams at larger companies
  • Teams building AI features

Tasks

  • Building a GraphQL API
  • Federating data sources
  • Setting up authorization
  • Safe schema changes
  • Self-hosting the engine

Scenarios

  • A startup ships its first app backend
  • An enterprise consolidates access
  • A team adds an AI assistant
  • A schema change is risky
  • A regulated company needs data residency

Key features

Supergraph Built From Metadata

Hasura DDN is a metadata-driven data access layer. You describe the shape of your data once, and the engine generates the API from that description instead of from code you write by hand. The result is a supergraph that federates many sources into one endpoint, with nested filters, pagination and sorting, plus aggregations out of the box. According to Hasura, the Rust-based compiler and runtime make it faster than the v2 engine, which the company had already called the fastest GraphQL engine.

Connectors for Databases, Code and APIs

Data connectors are how DDN reaches each source. Hasura ships official connectors for PostgreSQL, Microsoft SQL Server, CockroachDB, ClickHouse, MongoDB, Snowflake and others, plus code and API connectors for Lambda functions and REST services. They follow the open Native Data Connector (NDC) specification, so you can build your own connector and bring in a data source the official set does not cover. Hosting third-party and code connectors costs $0.075 per vCPU-hour and $0.0075 per GiB-hour.

GraphQL and Relay APIs

Every model becomes part of a GraphQL API that supports filters, pagination and sorting, plus aggregations, and the same layer exposes a Relay API for connection-based clients. Nested filters, nested aggregations, nested pagination and nested sorting come standard, which cuts the number of round trips a client needs. The free tier already includes these API features with no limit on requests per month.

Fine-Grained Authorization

Permissions run inside the engine at two levels. Field-level rules control which columns a role can read or write, and entity-level rules control which rows are visible. You define the logic declaratively in metadata, so the table, view or function in front of each API field is gated the same way everywhere. For teams with tight access requirements, one layer for authorization removes the drift that builds up when every service enforces its own rules.

Federated Collaboration and Multi-Repo CI/CD

The Advanced plan adds federated collaboration and multi-repo CI/CD, so several teams can work on independent subgraphs and merge them into one supergraph. Breaking-change detection, immutable builds and build URLs let you test a change in isolation before it reaches production. The schema registry and changelog track what changed and when, which matters once more than one team owns the API.

Observability and Usage Analytics

Traces, API performance metrics and model and field usage statistics are part of the console. The free plan keeps traces and metrics for 15 minutes, while paid plans extend retention to 30 days. Model and field usage statistics come with the paid plans and show which parts of the schema are actually used, which helps when you decide what to keep. Autoscaling, zero cold-start and a global edge network with geo routing are included on every plan.

Self-Hosting and Local Development

Not everything has to run in Hasura's cloud. You can self-host the v3 GraphQL Engine, run the same tooling locally with Docker, and develop against a supergraph on your machine before deploying. The DDN CLI handles init, connector setup and deployment in one workflow. That matters for teams that need to keep sensitive data on their own infrastructure while still getting the managed tooling.

PromptQL for AI Data Access

PromptQL is Hasura's AI layer for working with the supergraph. Instead of hard-coding SQL or GraphQL queries, you ask questions in natural language and PromptQL plans and runs the queries needed to answer them. It's built on the same data access layer, so the permissions and relationships you already defined still apply. For teams adding an assistant or a data app, this turns the supergraph into something an AI system can call directly.

Pros and cons

Pros

  • A metadata-driven supergraph turns many sources into one GraphQL endpoint without hand-written resolvers
  • Official and community connectors cover the major databases, plus code and REST APIs through the open NDC spec
  • Authorization runs in the engine at field and entity level, so rules live in one place instead of in every service
  • CI/CD with breaking-change detection and immutable builds makes schema changes safer to ship
  • A free tier covers unlimited requests and the core API features, so small projects can start without paying

Cons

  • DDN is a managed product with a real learning curve, and the metadata model and CLI take time to learn
  • Pricing counts active models rather than seats, so a large schema with many queried models can raise costs quickly
  • Hosting third-party and code connectors is billed by the hour, which adds up for always-on services
  • Self-hosting uses the v3 GraphQL Engine, so teams that want the full DDN experience stay on Hasura's cloud

Frequently asked questions

Hasura is a data access layer that turns databases, code and APIs into a single GraphQL API. Teams use it to build app backends, federate data from many sources and enforce permissions in one place, without writing resolvers for every table.