Hasura Cloud

What Hasura actually is

Hasura sits between your data and your application code: point it at databases and services, describe your data as models, and it generates a production GraphQL API — queries, filtering, pagination, aggregations, subscriptions, authorization — without you writing resolvers. The company was founded in 2017 by Tanmai Gopal and Rajoshi Ghosh, is headquartered in San Francisco, and raised $100 million in 2022 at a $1 billion valuation to push the product beyond its original "instant GraphQL on Postgres" pitch.

That pitch is worth updating, because the product line has moved. What many developers still call "Hasura Cloud" is now Hasura DDN — the Data Delivery Network — a managed supergraph platform. Instead of one project wired to one Postgres, DDN models data from databases, code and existing APIs as a federated graph served from a global edge network. The old mental model still works for the core case: you bring Postgres (or MySQL, or a code connector), Hasura introspects and exposes it. But pricing, limits and the deployment story are all DDN's now, and reviews describing the old Free/Standard/Enterprise tiers are out of date.

The open-source heritage remains intact. The GraphQL engine is self-hostable (the pricing page lists self-hosting with the v3 graphql-engine as a capability), which matters for our assessment: if the managed service ever stops fitting, you can run the engine yourself. Named customers on Hasura's own site include OpenAI, Siemens, Airbus, General Mills and Fujitsu — vendor-listed, but a plausible enterprise roster.

Pricing: what you really pay

Hasura's pricing is model-based rather than seat- or request-based, and the unit is the "active model": any model or command in your metadata accessed more than 1,000 times in a month. Idle models cost nothing. That is an unusual meter and we think it is genuinely aligned with value — you pay for what actually serves traffic.

DDN Free is $0 and, unusually for a free tier, includes unlimited models at any scale, one supergraph developer, unlimited API requests, unlimited concurrent API users, autoscaling, zero cold-start, the global edge network, intelligent geo-routing and DDoS protection. The real limit is team size (one developer) and observability retention (15 minutes). If you are one developer building a real product, this tier is not a demo — it is the product.

DDN Base starts at $5 per active model per month and adds unlimited supergraph developers, 30-day trace retention, model and field usage statistics, and a schema registry with diffs. DDN Advanced is $30 per active model per month and is aimed at multi-team, federated work: multi-repo CI/CD, team-based access controls, SSO, audit logs, custom firewall rules, and compliance options including HIPAA, plus the Private DDN deployment path (dedicated data plane on your infrastructure or Hasura's, with VPC peering and choice of cloud and region for data residency). Optional hosting for third-party and code connectors is billed separately at $0.075 per vCPU-hour and $0.0075 per GiB-hour. All figures here come from Hasura's pricing page.

The honest caveats: the active-model definition takes ten minutes to internalize, and a chatty schema with many hot models scales the bill linearly — $5 per model adds up faster than a flat plan when your graph is wide. There is no published top price; Private DDN and anything enterprise-negotiated is quote-based.

Performance & infrastructure

The managed side is a global edge network with autoscaling, zero cold-start and intelligent geo-routing, and every tier — including Free — lists no limits on API requests or concurrent users. That architecture targets the classic GraphQL complaint (N+1 queries hammering a distant database) with query planning, and the console ships a query plan and trace viewer so you can see what a request actually costs before it costs you money. We have not benchmarked DDN ourselves; treat throughput figures you find elsewhere as anecdotal and check our /benchmarks page for the database side of the equation, which is usually where latency actually lives.

On data protection, the platform is SOC 2 Type 2 audited and GDPR compliant, with DDoS protection included at every tier. Data residency becomes a choice only on Advanced ("choice of cloud and regions" is an asterisked feature there), so European teams with strict residency requirements should not assume the Free tier serves from the EU.

The connector story is the infrastructure story in practice. Database connectors cover the usual suspects, code connectors let you wrap arbitrary logic, and API connectors stitch in existing services — a federated supergraph rather than a single-database facade. The self-hosting escape hatch (v3 graphql-engine) means the architecture is not a dead end if you outgrow the managed plane.

Where it falls short

Hasura's concepts are its own. Models, supergraphs, connectors, active models, metadata builds, immutable build URLs — the learning curve is real even for experienced GraphQL developers, and the docs assume you are building for the long run. If your need is "expose this Postgres this afternoon," the older one-database mental model still fits, but you will be learning DDN vocabulary regardless.

The meter needs modelling before you commit. A schema where most models are hot pays per model; a small hot core pays almost nothing. Teams that treat pricing as a fixed line item should run their own usage estimate first. Similarly, connector hosting billed per vCPU-hour is transparent but moves cost into a dimension most teams do not monitor.

There is no published uptime SLA on the pricing page, and support entitlements are tied to plan tiers without a public response-time matrix. For a service that sits on the request path of production applications, we would want both in writing. The compliance items (HIPAA, data processing agreement, dedicated VPC) being Advanced-only is standard practice but worth pricing in early if you need them.

Finally, GraphQL itself is a commitment. If your consumers are mobile clients with changing needs, the typed contract is a feature; if you are serving simple internal CRUD, a plain REST layer over your ORM is less machinery.

The day-to-day developer experience is better than the pricing page suggests. The console includes a supergraph explorer and registry, a query plan and trace viewer, breaking-change detection, and immutable builds with permanent build URLs — which quietly solves the "the API changed under my feet" class of incident. Local development is a first-class path (build and test against a local engine before deploying), and CI/CD hooks support the workflow where a schema change opens a pull request rather than surprising a client team. For us, this tooling is the difference between an API generator and an API platform, and it is present even on the free tier.

Migration from the older Hasura Cloud experience is mostly conceptual rather than painful: your Postgres or MySQL connection moves to a database connector, your permission rules map to field and entity-level authorization, and subscriptions still exist. The teams who struggle are those expecting the exact v2 project model; the teams who do well treat DDN as a fresh, better-architected version of the same idea.

Who should pick this

Our pick for teams that want a production GraphQL API without building and operating a resolver layer — especially product teams with several data sources to federate, and solo developers who can build a real business on the Free tier's unlimited models. The schema tooling (registry, diff, breaking-change detection, immutable builds) is the part we would single out for teams that ship API changes weekly.

It also fits platform teams standardizing data access across services: one authorization model (field and entity level), one query contract, connectors instead of bespoke integration code.

Skip it if you need strict EU data residency on a small budget, if your usage is one hot database and a simple API, or if nobody wants to learn Hasura's modeling layer. Traditional managed database offerings in /category/database-hosting may be a better fit there.

Key takeaways

• Hasura generates a full GraphQL API — queries, subscriptions, authorization — from your databases and services.
• Pricing is per active model (models with >1,000 accesses/month): Free at $0, Base from $5, Advanced $30 per active model per month.
• The Free tier is unusually generous: unlimited models, unlimited API requests, global edge network and DDoS protection.
• Formerly "Hasura Cloud"; the current platform is Hasura DDN with federation, edge routing and optional Private DDN deployments.
• SOC 2 Type 2 and GDPR on every tier; HIPAA, SSO, audit logs and data-residency choice need Advanced.
• Best fit: teams standardizing on GraphQL across multiple data sources, and solo developers who want production API infrastructure at zero cost.

Sources

• https://hasura.io/pricing
• https://handwiki.org/wiki/Company:Hasura
• https://venturebeat.com/data-infrastructure/hasura-raises-100m-to-create-graphql-apis-for-databases