MongoDB

MySQL

Snowflake

Oracle

SQL Server

Amazon Athena

MariaDB

Google BigQuery

SQLite

DuckDB

Weaviate

DynamoDB

Redshift

Neo4j

Qdrant

Coming Soon

Build your own data connector today

Data connectors enable Hasura DDN to connect to an external data source and instantly get an amazing API. They translate incoming API requests into an efficient query that leverages the native strengths of the underlying data source.

Connectors are built on the open Native Data Connector (NDC) specification, and anyone can build a custom connector to bring a new data source into a Hasura API.

The Hasura Connector Hub lists all the official connectors included with Hasura DDN, and verified connectors contributed by the community. 

Follow this step-by-step course to build your own data connector.

Let’s build a connector

Get a detailed understanding of how connectors function.

Native Data Connector Spec

Our Rust and Typescript SDKs make it easy to build a connector. 

Explore our SDKs

Hasura data connectors

Check out docs for more information and guidance on data connectors out of the box, how to use them in your projects, or how to build your own.

Hasura native data connectors overview

Instantly build and operate a supergraph with zero operational overhead and baked-in security and performance capabilities. Use the connectors to plug into Hasura DDN and get a production-ready API instantly.

Hasura Data Delivery Network

Data connectors are the compatibility layer between Hasura and data sources, such as databases like PostgreSQL, APIs via REST, or any other structured source of data.

If you have a data source that’s not currently supported by Hasura, you can write a data connector to make it compatible!

You can use your own authored data connectors right away in your Hasura projects, but if you wish to have them promoted to the Hasura Community, you’ll need to verify them with us on the Hasura Hub.

Why build a native data connector?

Depending on what kind of integration you are targeting, there are several approaches to building a connector, ranging from quick-and-dirty easy-point solutions to deeply integrated full collection-based connectors. The best place to start is by going through the [NDC learn repo](https://github.com/hasura/ndc-learn).


From there, you can find an overview of the concepts involved, specification of the network protocol, SDKs, and example connector repositories.

How do I build my own connector?

Yes! We currently have a [Rust SDK](https://github.com/hasura/ndc-hub/tree/main/rust-connector-sdk) and [TypeScript SDK](https://github.com/hasura/ndc-sdk-typescript/tree/main). 

The native data connector [specification is available](https://hasura.github.io/ndc-spec/) and contains a [tutorial](https://hasura.github.io/ndc-spec/tutorial/index.html) outlining the protocol. Check out some of the existing examples of real connectors:
- [SendGrid](https://github.com/hasura/ndc-sendgrid)
- [ClickHouse](https://github.com/hasura/ndc-clickhouse)
- [TypeScript](https://github.com/hasura/ndc-typescript-deno/tree/main)

Are there SDKs and code examples to help build connectors?

You’re in luck! Just submit a PR to the [Connector Hub](https://github.com/hasura/ndc-hub/tree/main/registry), adding your connector to the `/registry` and we’ll review and provide feedback for any additional information required. Once that’s done, your connector will be listed on the Hub!

How do I publish my connector to the Hub?

The best way to contribute back to the SDKs and spec is to open issues on the repositories ([Rust](https://github.com/hasura/ndc-hub/tree/main/rust-connector-sdk), [TypeScript](https://github.com/hasura/ndc-sdk-typescript), [Spec](https://github.com/hasura/ndc-spec/tree/main)), then we can triage and prioritize it on our roadmap. Or, if you have a solution in mind, you can write a corresponding PR with a suggested implementation yourself!

How can I contribute to the specification and SDKs?

You have data. We have connectors that let you effortlessly deliver incredible APIs on that data.

Connector Hub

Lorem ipsum dolor sit amet consectetur. Habitasse non tortor nisl nascetur aliquam mattis sit leo. Volutpat semper risus tincidunt tellus sed at molestie sed sapien. Lectus.

Apply to get your data connector verified by Hasura

Connect to user-supplied typescript functions and expose them to Hasura Cloud v3 project

typescript-deno

Typescript (Deno) Connector

The Go connector allows you to expose Go functions as NDC functions/procedures for use in your Hasura DDN subgraphs.

Go Connector

The Qdrant Data Connector allows for connecting to a Qdrant instance giving you an instant GraphQL API on top of your Qdrant Vector Data.

qdrant

Qdrant Data Connector

Connect to SendGrid v3 API and expose it to Hasura Cloud v3 project

sendgrid

SendGrid Native Data Connector

Connect to a MongoDB database and expose it to Hasura v3 Project

mongodb

MongoDB Connector

Connect to a PostgreSQL database and expose them to Hasura v3 Project

spanner

(Google Spanner) PostgreSQL Native Data Connector

The NodeJS Lambda connector allows you to expose TypeScript functions as NDC functions/procedures for use in your Hasura DDN subgraphs.

nodejs-lambda

NodeJS Lambda Connector

yugabyte

(YugabyteDB) PostgreSQL Native Data Connector

Connect Hasura DDN to a Azure Cosmos DB for PostgreSQL database

postgres-cosmos

Azure CosmosDB PostgreSQL

Connect Hasura DDN to a PostgreSQL database

postgres

PostgreSQL Native Data Connector

Connect Hasura DDN to a Neon Postgres database

neon

Neon

Connect Hasura DDN to an Azure Postgres database

postgres-azure

Azure Database for PostgreSQL

Connect Hasura DDN to a Google Cloud SQL Postgres database

postgres-gcp

GCP Cloud SQL Postgres

Connect Hasura DDN to a CockroachDB Postgres database

cockroach

CockroachDB

Connect Hasura DDN to an AWS Aurora Postgres database

aurora

AWS Aurora Postgres

Connect Hasura DDN to a TimescaleDB database

postgres-timescaledb

TimescaleDB

Connect Hasura DDN to a Citus Postgres database

citus

Citus

The Clickhouse Native Data Connector allows for connecting to a Clickhouse instance giving you an instant GraphQL API on top of your Clickhouse data.