docs.dgraph.io

docs.dgraph.io is the official documentation site for Dgraph, an open-source, distributed graph database built for real-time workloads and terabyte-scale data. The site is where you go to learn how to run Dgraph as a property graph database or generate a GraphQL API and graph backend from a GraphQL schema. It serves two audiences with one codebase: teams that want direct database operations and administration, and developers who want schema-driven APIs for faster application development.

What Dgraph is, according to the documentation

The site describes Dgraph as "the only open, complete graph database used at terabyte-scale to power real-time use cases." The stated properties are:

• Open-source — the database itself is open.
• Scalable and distributed — implemented as a distributed system.
• Highly available — designed to keep serving under failure.
• Fast — queries are processed in parallel, which the docs frame as delivering the fastest results even for complex workloads.
• Flexible — designed for data flexibility alongside real-time performance.

These are the vendor's own claims from the documentation homepage, not independent benchmarks. Treat them as the design goals Dgraph is built around rather than verified performance numbers.

The two paths the documentation offers

The homepage explicitly asks you to "choose your path," and the split matters because it determines which half of the docs you'll spend time in.

Path 1: Dgraph DB

Use Dgraph as a property graph database for direct database operations and administration. This path covers getting started, day-to-day use, and operating the database. Choose it if you want to:

• Model and query a graph directly rather than through a generated API layer.
• Manage and administer the database yourself.
• Work at the level of the database rather than an application schema.

Path 2: GraphQL API

Use the GraphQL API to generate a GraphQL API and a graph backend from your GraphQL schema. This path is aimed at rapid application development with schema-driven APIs. Choose it if you want to:

• Start from a GraphQL schema you already have or plan to write.
• Get both the API and the backing graph store generated from that schema.
• Move quickly on application development without hand-building the backend.

How to decide which path fits

If you're unsure, the deciding question is whether your starting point is the database or the schema. Starting from the database points to Dgraph DB; starting from a GraphQL schema points to the GraphQL API.

What the site is for

The documentation exists to help you get started, operate, and build with Dgraph. Concretely, that means it's the reference for:

• Getting started — initial setup and first steps.
• Using the database in normal operation.
• Operating it as a running system.
• Building applications, either directly against the database or through the generated GraphQL API.

Practical notes

• The documentation is in English.
• The homepage does not state pricing, licensing tiers, or login requirements. Don't assume the hosted or managed offerings are free just because the database is described as open-source — check the relevant product pages for that.
• Because Dgraph is described as a distributed system, expect operational topics (running and administering it) to be a meaningful part of the Dgraph DB path, not an afterthought.

If you're evaluating Dgraph, the fastest way to use this site is to pick your path first, then follow that path's getting-started material before branching into administration or API details.

Start at docs.dgraph.io and pick one of the two documented paths: Dgraph DB if you want direct database operations and administration, or GraphQL API if you want to generate a GraphQL API and graph backend from your own GraphQL schema. The right choice depends on whether your application already speaks GraphQL or you need lower-level control over the database.

What the documentation covers

The Dgraph Documentation site describes Dgraph as an open, complete graph database built for terabyte-scale, real-time workloads. The documented characteristics are:

• Open-source
• Scalable and distributed
• Highly available
• Designed for real-time workloads, horizontal scalability, and data flexibility
• Implemented as a distributed system that processes queries in parallel

The homepage splits the documentation into two entry points, and the excerpt states the intended use of each:

Choosing your path

Use Dgraph DB if you need direct control

Choose this path when you want to work with Dgraph as a property graph database — running database operations and administering the cluster yourself. The documentation describes this as the route for direct database operations and administration.

Use the GraphQL API if you already have a schema

Choose this path when you want a schema-driven API without building the backend layer by hand. The documentation states that you generate both a GraphQL API and a graph backend from your GraphQL schema, which is aimed at rapid application development.

If you are unsure, the deciding question is whether a GraphQL schema is your starting point. If yes, the GraphQL API path matches the documented workflow. If you need to operate and administer the database directly, start with Dgraph DB.

Getting started, step by step

The documentation is organized so that each path begins with a "Get started" entry rather than a single combined tutorial. To work through it:

1. Open docs.dgraph.io.
2. Decide between the Dgraph DB and GraphQL API sections using the criteria above.
3. Enter the "Get started" material for the path you chose. For Dgraph DB, this is the documented starting point for using and operating the database.
4. Follow that section's setup material before attempting queries, since the homepage does not itself contain installation or configuration steps.
5. For the GraphQL API path, begin from your GraphQL schema, because the documented output is a generated API and graph backend derived from that schema.

Expected result: after completing the "Get started" material for your chosen path, you should be positioned to either run direct database operations (Dgraph DB) or call a generated GraphQL API backed by a graph backend (GraphQL API).

What to look for next

Once past the starting material, the documentation points toward two ongoing areas of work:

• Using and operating the database — the Dgraph DB path covers both use and operation, so expect administration topics alongside query topics.
• Schema-driven API development — the GraphQL API path is framed around generating the API and backend from a schema, so schema design is the recurring input.

Common sticking points

• Treating the two paths as sequential. They are presented as alternatives ("Choose your path"), not as steps one after another. Pick the one that matches your starting point.
• Expecting the homepage to contain setup commands. The excerpt only names the two entry points and their purposes; the actual setup and operations guidance lives inside each section.
• Assuming a single unified tutorial. Because the documentation splits into Dgraph DB and GraphQL API, search within the section you chose rather than across the whole site.

Quick reference

Dgraph is an open-source, complete graph database built for terabyte-scale, real-time workloads. According to the Dgraph Documentation, it is distributed, horizontally scalable, highly available, and designed for data flexibility, processing queries in parallel to return fast results even on complex workloads. If you need a graph database for real-time use cases that must scale beyond a single machine, Dgraph is positioned for exactly that; if you only need a small embedded graph store, its distributed architecture may be more than you require.

Core characteristics

The documentation describes Dgraph along five main dimensions:

• Open and complete — it is open-source and presented as a complete graph database rather than a partial or add-on solution.
• Terabyte-scale — it is explicitly described as being used at terabyte scale to power real-time use cases.
• Real-time workloads — the system is designed for real-time performance rather than batch-oriented analytics.
• Distributed system — Dgraph is implemented as a distributed system, which is what enables the scalability and availability properties below.
• Data flexibility — the design accommodates flexible data, which fits graph modeling where relationships and shapes vary.

Scalability and availability

Because Dgraph is implemented as a distributed system, two properties follow directly from that architecture:

The parallel query processing is the mechanism behind the speed claim: rather than executing a query in a single thread or on a single node, Dgraph splits the work so that complex workloads still return results quickly.

Two ways to use Dgraph

The documentation frames the product around a choice of path, and this is the most practical feature distinction for anyone evaluating it:

Dgraph DB

Use Dgraph as a property graph database for direct database operations and administration. This path suits you if you want to work with the graph directly — running queries and mutations, and operating the database yourself.

GraphQL API

Use the GraphQL API for rapid application development with schema-driven APIs. The documentation describes this path as generating a GraphQL API and a graph backend from your GraphQL schema. This suits you if you would rather define a schema and let Dgraph produce the API and backing graph for you.

The choice between them is not about capability so much as workflow: direct database control versus schema-driven API generation for faster application development.

How to decide whether it fits

Use the documented features as a checklist against your own requirements:

• Choose Dgraph if your workload is real-time, your data volume reaches terabyte scale, and you need horizontal scalability and high availability from a distributed system.
• Consider the GraphQL API path if you want to move quickly from a GraphQL schema to a working API and backend.
• Consider the Dgraph DB path if you need direct database operations and administration.
• Look elsewhere if your data fits comfortably in a single node and you do not need distribution, since the distributed design is the source of both its strengths and its operational complexity.

For setup instructions, query syntax, and operational details, the documentation itself is the authoritative next step: start from the Dgraph DB or GraphQL API section depending on the path you chose above.

Dgraph Documentation presents two entry paths, and the right one depends on what you are building. Choose Dgraph DB when you need direct database operations and administration, such as running DQL queries, managing clusters, and controlling data at the database level. Choose the GraphQL API when you want to generate a GraphQL API and a graph backend from your GraphQL schema, which is aimed at rapid application development with schema-driven APIs. The documentation frames this as "Choose your path," so the decision is about your working style and control needs rather than one path being strictly better.

Dgraph DB: direct database operations and administration

The Dgraph DB path is for teams that want to work with Dgraph as a property graph database directly. According to the documentation, this path covers getting started, using, and operating the Dgraph database.

Typical work in this path includes:

• Writing and running queries against the graph using Dgraph's own query language
• Managing schema and data at the database layer
• Operating the database, including the concerns that come with a distributed system
• Handling administration tasks for a scalable, highly available deployment

This path suits you if you want operational control and are comfortable treating Dgraph as the database itself, with your application talking to it through the database's native interfaces.

GraphQL API: schema-driven API and graph backend generation

The GraphQL API path is for teams that want to start from a GraphQL schema. The documentation describes it as generating a GraphQL API and a graph backend from your GraphQL schema.

Typical work in this path includes:

• Defining your data model as a GraphQL schema
• Letting Dgraph generate the API and the backing graph
• Building applications against a schema-driven API rather than hand-writing database operations
• Moving faster on application development where the schema is the source of truth

This path suits you if rapid application development matters more than direct, low-level database control, and if your team already thinks in GraphQL.

How the two paths compare

The documentation does not present these as mutually exclusive in every scenario, but it does ask you to choose a path, which suggests picking the one that matches your primary workflow.

How to decide

Use these questions to pick a path:

1. Is your schema already defined in GraphQL? If yes, the GraphQL API path lets you generate the API and backend from it.
2. Do you need direct database operations and administration? If yes, the Dgraph DB path is the one described for that work.
3. Is your priority speed of application development or depth of database control? The documentation associates the GraphQL API path with rapid application development and the Dgraph DB path with direct operations and administration.
4. Who will operate the system? If your team wants to manage the database directly, start with Dgraph DB; if your team wants to work mainly through a generated API, start with the GraphQL API.

Where to go in the documentation

The documentation homepage splits into two sections that match these paths:

• Dgraph DB — "Get started, use and operate Dgraph database."
• GraphQL API — "Generate a GraphQL API and a graph backend from your GraphQL schema."

Start with the section that matches your answer above. If you are unsure, begin with the path whose description matches your immediate task: operating and querying the database directly points to Dgraph DB, while generating an API from a schema points to the GraphQL API.

Dgraph Documentation (docs.dgraph.io) is the official documentation site for Dgraph, an open-source, distributed, highly available graph database built for real-time workloads and terabyte-scale data. For operations and administration work, the site's Dgraph DB section is the primary path: it covers getting started, using, and operating the database directly, while the separate GraphQL API section is aimed at schema-driven application development rather than cluster administration. If your job is running, scaling, or maintaining a Dgraph deployment, start in the Dgraph DB section; if you are generating an API layer from a GraphQL schema, the GraphQL API section is the relevant one.

What the documentation covers

The site presents two distinct paths, and the split matters for administrators:

The documentation describes Dgraph as open-source, scalable, distributed, highly available, and designed for real-time workloads and horizontal scalability. It is implemented as a distributed system that processes queries in parallel. Those properties are exactly what shape the operational tasks you will need documentation for.

Where to look for administration and operations content

Because the site organizes content under the Dgraph DB heading, that section is where to find material on getting started, using, and operating the database. When you need to answer a specific operational question, map it to the property it touches:

• Distributed operation — Dgraph runs as a distributed system, so expect operational content to address multi-node concerns rather than single-process setup.
• High availability — availability is a stated design property, so look for guidance framed around keeping the database serving under failure rather than only initial installation.
• Real-time workloads — the database is positioned for real-time use cases, which means operational guidance is oriented toward latency-sensitive serving, not batch-only analytics.
• Horizontal scalability — scaling out is a design goal, so capacity and growth questions belong with the scalability material rather than the application-development path.

Choosing between the two paths

Use this as a decision rule rather than a preference:

• Choose Dgraph DB when your task is direct database operations or administration — running, operating, and managing the database itself.
• Choose GraphQL API when your task is rapid application development with a schema-driven API generated from your GraphQL schema.

These are complementary, not competing: the same deployment can be administered through the Dgraph DB path while applications consume it through a generated GraphQL API. The documentation's own framing is "choose your path," so pick based on whether your immediate problem is operating the database or building against it.

Practical starting point

1. Open docs.dgraph.io and identify which of the two headings — Dgraph DB or GraphQL API — matches your task.
2. For operations and administration, enter through Dgraph DB, which the site describes as covering getting started, use, and operation.
3. Frame your question in terms of the documented design properties (distributed, highly available, real-time, horizontally scalable) so you land on the right operational topic.
4. Treat the GraphQL API section as the destination only when your goal is generating an API and graph backend from a schema.

Limits to keep in mind

The available site material establishes the structure and positioning of the documentation but does not enumerate specific administration commands, configuration parameters, or version-specific procedures. For those details, work from the Dgraph DB section itself rather than assuming coverage from the overview. Pricing and access terms are not stated in the source material, so do not assume the documentation or the database is free or requires no login based on this overview alone.