graphql vs express-graphql vs apollo
GraphQL Libraries for Node.js Comparison
Search packages..
1 Year
graphqlexpress-graphqlapolloSimilar Packages:
What's GraphQL Libraries for Node.js?

GraphQL libraries for Node.js provide tools and frameworks to build GraphQL APIs, allowing developers to define a schema, handle queries, and manage data fetching in a more efficient manner compared to traditional REST APIs. These libraries facilitate the creation of flexible and powerful APIs that enable clients to request exactly the data they need, reducing over-fetching and under-fetching issues. They also support features like real-time updates and subscriptions, making them suitable for modern web applications that require dynamic data handling.

Package Weekly Downloads Trend
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
graphql16,120,68120,2001.37 MB16515 days agoMIT
express-graphql308,6016,313-554 years agoMIT
apollo127,1483,043288 kB382-MIT
Feature Comparison: graphql vs express-graphql vs apollo

Integration

  • graphql:

    The GraphQL package is the core library that implements the GraphQL specification. It does not provide any specific integration features but allows developers to build their own GraphQL server from scratch, giving them the freedom to customize the implementation as needed.

  • express-graphql:

    Express-GraphQL is designed to work directly with the Express framework, allowing developers to easily add GraphQL capabilities to their existing Express applications. It provides a simple middleware that can be integrated into any Express app, making it straightforward to set up and use.

  • apollo:

    Apollo provides seamless integration with various front-end frameworks and libraries, such as React, Angular, and Vue. It offers a complete suite of tools, including Apollo Client, which simplifies data fetching and state management on the client side, making it easier to build responsive applications.

Complexity

  • graphql:

    The GraphQL library is the most basic option, requiring developers to handle all aspects of the GraphQL server implementation. This can lead to increased complexity as developers need to manage everything from schema definition to resolver functions without any built-in conveniences.

  • express-graphql:

    Express-GraphQL is relatively simple and easy to use, making it a good choice for developers who want to get started with GraphQL quickly. It requires minimal configuration and is straightforward to set up, making it suitable for small to medium-sized applications.

  • apollo:

    Apollo introduces additional complexity due to its extensive features and ecosystem. While it offers powerful capabilities, developers need to understand its caching mechanisms, state management, and how to effectively use its tools to fully leverage its potential.

Performance

  • graphql:

    The performance of a GraphQL server built with the GraphQL library depends heavily on how it is implemented. Developers have full control over optimizations, but this also means they must be diligent in writing efficient resolvers and managing data fetching to avoid performance bottlenecks.

  • express-graphql:

    Express-GraphQL is lightweight and performs well for most use cases. However, performance can depend on how well the resolvers are implemented and the complexity of the queries being executed. Developers need to be mindful of optimizing their resolvers to ensure good performance.

  • apollo:

    Apollo Client includes advanced caching strategies that optimize data fetching and minimize network requests, improving the overall performance of applications. It intelligently manages data and updates the UI efficiently, which is particularly beneficial for applications with complex data requirements.

Community and Ecosystem

  • graphql:

    The GraphQL library is the foundation of the GraphQL ecosystem and has a strong community backing. However, since it is a lower-level library, developers may need to rely on additional libraries and tools to build a complete solution, which can lead to fragmentation.

  • express-graphql:

    Express-GraphQL has a smaller community compared to Apollo but benefits from the larger Express community. It is well-documented and has a straightforward approach, making it easy for developers to find resources and support for basic GraphQL implementations.

  • apollo:

    Apollo has a large and active community, providing extensive documentation, tutorials, and third-party tools. The ecosystem includes various libraries and integrations that enhance its capabilities, making it a popular choice for developers looking for robust support and resources.

Learning Curve

  • graphql:

    The GraphQL library requires a solid understanding of GraphQL concepts and principles. While it offers flexibility, the learning curve can be steep for those unfamiliar with building GraphQL servers from scratch.

  • express-graphql:

    Express-GraphQL is easy to learn, especially for developers already familiar with Express. Its straightforward setup and minimal configuration make it accessible for those new to GraphQL, allowing for a quicker onboarding process.

  • apollo:

    Apollo has a steeper learning curve due to its extensive features and concepts like caching, state management, and subscriptions. Developers may need to invest time in understanding how to effectively use Apollo's tools to maximize their benefits.

How to Choose: graphql vs express-graphql vs apollo
  • graphql:

    Choose GraphQL if you are looking for the core library to implement GraphQL specifications and want to build your own custom server without any framework constraints. It is best for developers who want complete control over their GraphQL implementation and are comfortable with more manual setup.

  • express-graphql:

    Choose Express-GraphQL if you are looking for a lightweight and straightforward way to integrate GraphQL into your existing Express application. It is suitable for developers who prefer minimal setup and want to quickly get started with GraphQL without additional overhead.

  • apollo:

    Choose Apollo if you need a comprehensive solution that includes client and server capabilities, advanced caching, and state management features. Apollo is ideal for applications that require complex data interactions and want to leverage its extensive ecosystem, including tools for testing and performance monitoring.

Similar Npm Packages to graphql

graphql is a powerful query language for APIs and a runtime for executing those queries with your existing data. It provides a more efficient, powerful, and flexible alternative to REST. With GraphQL, clients can request exactly the data they need, making it easier to manage and optimize data fetching. While GraphQL itself is a robust specification, there are several libraries that help implement GraphQL servers. Here are a few popular alternatives:

  • apollo-server is a community-driven, open-source GraphQL server that works with any GraphQL schema. It is designed to be easy to set up and integrate with various Node.js frameworks, including Express, Koa, and Hapi. Apollo Server provides built-in support for features like subscriptions, middleware, and performance tracing, making it a great choice for building production-ready GraphQL APIs. If you are looking for a comprehensive solution that simplifies the process of building and deploying GraphQL servers, Apollo Server is an excellent option.
  • express-graphql is a middleware for Express that allows you to create a GraphQL API with minimal setup. It provides a straightforward way to integrate GraphQL into your existing Express applications, making it easy to define your GraphQL schema and resolvers. If you are already using Express and want to add GraphQL capabilities to your application without introducing additional complexity, express-graphql is a solid choice.
  • graphql-yoga is a fully-featured GraphQL server that is built on top of Express and other popular libraries. It aims to provide a simple and easy-to-use setup for creating GraphQL APIs, with built-in support for features like subscriptions, file uploads, and more. graphql-yoga is particularly appealing for developers who want a quick and easy way to get started with GraphQL without having to configure many options. It’s a great choice for prototyping and small to medium-sized applications.

To explore how these packages compare, check out the comparison: Comparing apollo-server vs express-graphql vs graphql vs graphql-yoga.

Similar Npm Packages to express-graphql

express-graphql is a middleware for integrating GraphQL with Express.js, allowing developers to build GraphQL APIs easily and efficiently. It provides a straightforward way to set up a GraphQL server, enabling developers to define their schema and resolvers while leveraging the power of Express.js for handling HTTP requests. With express-graphql, you can quickly create a robust GraphQL endpoint that can serve complex data queries and mutations.

While express-graphql is a popular choice for building GraphQL APIs, there are other libraries that serve similar purposes. Here are a few alternatives:

  • apollo-server-express is part of the Apollo Server ecosystem, which is widely used for building GraphQL APIs. It integrates seamlessly with Express.js, providing a rich set of features such as built-in support for subscriptions, caching, and performance tracing. Apollo Server also offers a powerful developer experience with tools like Apollo Client and Apollo Studio, making it an excellent choice for developers looking for a comprehensive solution for building GraphQL APIs.
  • graphql-yoga is a fully-featured GraphQL server that is easy to set up and use. It is built on top of Express.js and provides a simple API for creating GraphQL servers with features like real-time subscriptions, file uploads, and more. graphql-yoga is designed to be flexible and extensible, making it suitable for both small projects and larger applications. Its simplicity and ease of use make it a great option for developers looking to get started with GraphQL quickly.

To see how express-graphql compares with apollo-server-express and graphql-yoga, check out the comparison: Comparing apollo-server-express vs express-graphql vs graphql-yoga.

Similar Npm Packages to apollo

apollo is a comprehensive state management library for JavaScript applications that enables developers to manage both local and remote data with GraphQL. It provides a powerful set of tools for building GraphQL applications, including a client for querying and mutating data, as well as a server for handling GraphQL requests. Apollo's ecosystem is designed to work seamlessly with React, making it a popular choice for developers looking to integrate GraphQL into their applications. Its features include caching, real-time updates, and easy integration with existing APIs, which help streamline the development process and improve application performance.

While Apollo is a robust solution for working with GraphQL, there are alternatives that cater to different needs:

  • express-graphql is a middleware for building GraphQL APIs using the Express framework. It allows developers to create a GraphQL server quickly and easily by providing a simple way to define a GraphQL schema and handle requests. express-graphql is an excellent choice for those who want to build a GraphQL server from scratch or integrate GraphQL into an existing Express application. Its simplicity and flexibility make it a popular option for developers who prefer to have more control over their GraphQL implementation without the overhead of a full-fledged client like Apollo.

  • graphql is the core library for building GraphQL APIs. It provides the foundational tools necessary to define schemas, types, and resolvers, allowing developers to create a fully functional GraphQL server. While graphql itself does not provide a client-side solution or additional features like caching or state management, it serves as the backbone for many GraphQL implementations, including Apollo and express-graphql. If you are looking to build a custom GraphQL server and want complete control over the implementation, using the graphql library directly is a solid choice.

To see how Apollo compares with express-graphql and graphql, check out the comparison: Comparing apollo vs express-graphql vs graphql.

README for graphql

GraphQLConf 2025 Banner: September 08-10, Amsterdam. Hosted by the GraphQL Foundation

GraphQL.js

The JavaScript reference implementation for GraphQL, a query language for APIs created by Facebook.

npm version Build Status Coverage Status

See more complete documentation at https://graphql.org/ and https://graphql.org/graphql-js/.

Looking for help? Find resources from the community.

Getting Started

A general overview of GraphQL is available in the README for the Specification for GraphQL. That overview describes a simple set of GraphQL examples that exist as tests in this repository. A good way to get started with this repository is to walk through that README and the corresponding tests in parallel.

Using GraphQL.js

Install GraphQL.js from npm

With npm:

npm install --save graphql

or using yarn:

yarn add graphql

GraphQL.js provides two important capabilities: building a type schema and serving queries against that type schema.

First, build a GraphQL type schema which maps to your codebase.

import {
  graphql,
  GraphQLSchema,
  GraphQLObjectType,
  GraphQLString,
} from 'graphql';

var schema = new GraphQLSchema({
  query: new GraphQLObjectType({
    name: 'RootQueryType',
    fields: {
      hello: {
        type: GraphQLString,
        resolve() {
          return 'world';
        },
      },
    },
  }),
});

This defines a simple schema, with one type and one field, that resolves to a fixed value. The resolve function can return a value, a promise, or an array of promises. A more complex example is included in the top-level tests directory.

Then, serve the result of a query against that type schema.

var source = '{ hello }';

graphql({ schema, source }).then((result) => {
  // Prints
  // {
  //   data: { hello: "world" }
  // }
  console.log(result);
});

This runs a query fetching the one field defined. The graphql function will first ensure the query is syntactically and semantically valid before executing it, reporting errors otherwise.

var source = '{ BoyHowdy }';

graphql({ schema, source }).then((result) => {
  // Prints
  // {
  //   errors: [
  //     { message: 'Cannot query field BoyHowdy on RootQueryType',
  //       locations: [ { line: 1, column: 3 } ] }
  //   ]
  // }
  console.log(result);
});

Note: Please don't forget to set NODE_ENV=production if you are running a production server. It will disable some checks that can be useful during development but will significantly improve performance.

Want to ride the bleeding edge?

The npm branch in this repository is automatically maintained to be the last commit to main to pass all tests, in the same form found on npm. It is recommended to use builds deployed to npm for many reasons, but if you want to use the latest not-yet-released version of graphql-js, you can do so by depending directly on this branch:

npm install graphql@git://github.com/graphql/graphql-js.git#npm

Experimental features

Each release of GraphQL.js will be accompanied by an experimental release containing support for the @defer and @stream directive proposal. We are hoping to get community feedback on these releases before the proposal is accepted into the GraphQL specification. You can use this experimental release of GraphQL.js by adding the following to your project's package.json file.

"graphql": "experimental-stream-defer"

Community feedback on this experimental release is much appreciated and can be provided on the issue created for this purpose.

Using in a Browser

GraphQL.js is a general-purpose library and can be used both in a Node server and in the browser. As an example, the GraphiQL tool is built with GraphQL.js!

Building a project using GraphQL.js with webpack or rollup should just work and only include the portions of the library you use. This works because GraphQL.js is distributed with both CommonJS (require()) and ESModule (import) files. Ensure that any custom build configurations look for .mjs files!

Contributing

We actively welcome pull requests. Learn how to contribute.

This repository is managed by EasyCLA. Project participants must sign the free (GraphQL Specification Membership agreement before making a contribution. You only need to do this one time, and it can be signed by individual contributors or their employers.

To initiate the signature process please open a PR against this repo. The EasyCLA bot will block the merge if we still need a membership agreement from you.

You can find detailed information here. If you have issues, please email operations@graphql.org.

If your company benefits from GraphQL and you would like to provide essential financial support for the systems and people that power our community, please also consider membership in the GraphQL Foundation.

Changelog

Changes are tracked as GitHub releases.

License

GraphQL.js is MIT-licensed.

npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc or npmjs.com, the official website for the npm registry. Please note that npm is a registered trademark of npm, Inc. For more details, please refer to our Terms & Privacy.